Upload 51 files

.gitattributes

@@ -1,3 +1,4 @@
 * linguist-vendored
 *.py linguist-vendored=false
 text eol=lf
+openbb_platform/obbject_extensions/charting/openbb_charting/core/assets/Terminal_icon.png filter=lfs diff=lfs merge=lfs -text

openbb_platform/obbject_extensions/charting/README.md

@@ -0,0 +1,174 @@
+# OpenBB Charting extension
+
+This extension provides a charting library for OpenBB Platform.
+
+The library includes:
+
+- a charting infrastructure based on Plotly
+- a set of charting components
+- prebuilt charts for a set of commands that are built-in OpenBB extensions
+
+>[!NOTE]
+> The charting library is an `OBBject` extension which means you'll have the functionality it exposes on every command result.
+
+## Installation
+
+To install the extension, run the following command in this folder:
+
+```bash
+pip install openbb-charting
+```
+
+## PyWry dependency on Linux
+
+The PyWry dependency handles the display of interactive charts and tables in a separate window. It is installed automatically with the OpenBB Charting extension.
+
+When using Linux distributions, the PyWry dependency requires certain dependencies to be installed first.
+
+- Debian-based / Ubuntu / Mint:
+`sudo apt install libwebkit2gtk-4.0-dev`
+
+- Arch Linux / Manjaro:
+`sudo pacman -S webkit2gtk`
+
+- Fedora:
+`sudo dnf install gtk3-devel webkit2gtk3-devel`
+
+## Usage
+
+To use the extension, run any of the OpenBB Platform endpoints with the `chart` argument set to `True`.
+
+Here's an example of how it would look like in a python interface:
+
+```python
+from openbb import obb
+equity_data = obb.equity.price.historical(symbol="TSLA", chart=True)
+```
+
+This results in a `OBBject` object containing a `chart` attribute, which contains Plotly JSON data.
+
+In order to display the chart, you need to call the `show()` method:
+
+```python
+equity_data.show()
+```
+
+> Note: The `show()` method currently works either in a Jupyter Notebook or in a standalone python script with a PyWry based backend properly initialized.
+
+Alternatively, you can use the fact that the `openbb-charting` is an `OBBject` extension and use its available methods.
+
+```python
+from openbb import obb
+res = obb.equity.price.historical("AAPL")
+res.charting.show()
+```
+
+The above code will produce the same effect as the previous example.
+
+### Discovering available charts
+
+Not all the endpoints are currently supported by the charting extension. To discover which endpoints are supported, you can run the following command:
+
+```python
+from openbb_charting import Charting
+Charting.functions()
+```
+
+### Using the `to_chart` method
+
+The `to_chart` function should be taken as an advanced feature, as it requires the user to have a good understanding of the charting extension and the `OpenBBFigure` class.
+
+The user can use any number of `**kwargs` that will be passed to the `PlotlyTA` class in order to build custom visualizations with custom indicators and similar.
+
+> Note that, this method will only work to some limited extent with data that is not standardized.
+> Also, it is currently designed only to handle time series (OHLCV) data.
+
+Example usage:
+
+- Plotting a time series with TA indicators
+
+  ```python
+
+    from openbb import obb
+    res = obb.equity.price.historical("AAPL")
+
+    indicators = dict(
+        sma=dict(length=[20,30,50]),
+        adx=dict(length=14),
+        rsi=dict(length=14),
+        macd=dict(fast=12, slow=26, signal=9),
+        bbands=dict(length=20, std=2),
+        stoch=dict(length=14),
+        ema=dict(length=[20,30,50]),
+    )
+    res.charting.to_chart(**{"indicators": indicators})
+
+  ```
+
+- Get all the available indicators
+
+    ```python
+
+    # if you have a command result already
+    res.charting.indicators
+
+    # or if you want to know in standalone fashion
+    from openbb_charting import Charting
+    Charting.indicators()
+
+    ```
+
+## Add a visualization to an existing Platform command
+
+To add a visualization to an existing command, you'll need to add a `poetry` plugin to your `pyproject.toml` file. The syntax should be the following:
+
+```toml
+[tool.poetry.plugins."openbb_charting_extension"]
+my_extension = "openbb_my_extension.my_extension_views:MyExtensionViews"
+```
+
+Where the `openbb_charting_extension` is **mandatory**, otherwise the charting extension won't be able to find the visualization.
+
+And the suggested structure for the `my_extension_views` module is the following:
+
+```python
+"""Views for MyExtension."""
+
+from typing import Any, Dict, Tuple
+
+from openbb_charting.charts.price_historical import price_historical
+from openbb_charting.core.openbb_figure import OpenBBFigure
+
+
+class MyExtensionViews:
+    """MyExtension Views."""
+
+    @staticmethod
+    def my_extension_price_historical(
+        **kwargs,
+    ) -> Tuple[OpenBBFigure, Dict[str, Any]]:
+        """MyExtension Price Historical Chart."""
+        return price_historical(**kwargs)
+```
+
+> Note that `my_extension_views` lives under the `openbb_my_extension` package.
+
+Afterwards, you'll need to add the visualization to your new `MyExtensionViews` class. The convention to match the endpoint with the respective charting function is the following:
+
+- `/equity/price/historical` -> `equity_price_historical`
+- `/technical/ema` -> `technical_ema`
+- `/my_extension/price_historical` -> `my_extension_price_historical`
+
+When you spot the charting function on the charting router file, you can add the visualization to it.
+
+The implementation should leverage the already existing classes and methods to do so, namely:
+
+- `OpenBBFigure`
+- `PlotlyTA`
+
+Note that the return of each charting function should respect the already defined return types: `Tuple[OpenBBFigure, Dict[str, Any]]`.
+
+The returned tuple contains a `OpenBBFigure` that is an interactive plotly figure which can be used in a Python interpreter, and a `Dict[str, Any]` that contains the raw data leveraged by the API.
+
+After you're done implementing the charting function, you can use either the Python interface or the API to get the chart. To do so, you'll only need to set the already available `chart` argument to `True`.
+Or accessing the `charting` attribute of the `OBBject` object: `my_obbject.charting.show()`.

openbb_platform/obbject_extensions/charting/examples.md

@@ -0,0 +1,166 @@
+---
+title: Examples
+sidebar_position: 1
+description: This page provides examples of creating charts with the `openbb-charting` extension.
+keywords:
+- tutorial
+- OpenBB Platform
+- Python client
+- Fast API
+- getting started
+- extensions
+- charting
+- view
+- Plotly
+- toolkits
+- how-to
+- generic
+- figure
+---
+
+import HeadTitle from '@site/src/components/General/HeadTitle.tsx';
+
+<HeadTitle title="Examples - OpenBB Charting - Extensions | OpenBB Platform Docs" />
+
+## Overview
+
+This page will walk through creating different charts using the `openbb-charting` extension.
+The perspective for this content is from the Python Interface,
+and the examples will assume that the OpenBB Platform is installed with all optional packages.
+
+```python
+from datetime import datetime, timedelta
+from openbb import obb
+```
+
+## Cumulative Returns
+
+The historical (equity) prices can be requested for multiple symbols.
+The extension will attempt to handle variations accordingly.
+By default, more than three symbols will draw the chart as cumulative returns from the beginning of the series.
+
+### Default View
+
+The tickers below are a collection of State Street Global Advisors SPDR funds, representing S&P 500 components.
+The data is looking back five years.
+
+```python
+SPDRS = [
+    "SPY",
+    "XLE",
+    "XLB",
+    "XLI",
+    "XHB",
+    "XLP",
+    "XLY",
+    "XRT",
+    "XLF",
+    "XLV",
+    "XLK",
+    "XLC",
+    "XLU",
+    "XLRE",
+]
+start_date = (datetime.now() - timedelta(weeks=52*5)).date()
+spdrs = obb.equity.price.historical(SPDRS, start_date=start_date, provider="yfinance", chart=True)
+
+spdrs.show()
+```
+
+![SPDRs Cumulative Returns - 5 years](https://github.com/OpenBB-finance/OpenBB/assets/85772166/8884f4ed-b09c-4161-9dc6-87ad66d9fc8b)
+
+### Redraw as YTD
+
+The `charting` attribute of the command output has methods for creating the chart again.
+The `data` parameter allows modifications to the data before creating the figure.
+In this example, the length of the data is trimmed to the beginning of the year.
+
+```python
+new_data = spdrs.to_df().loc[datetime(2024,12,29).date():]
+spdrs.charting.to_chart(data=new_data, title="YTD")
+```
+
+:::note
+This replaces the chart that was already created.
+:::
+
+![SPDRs Cumulative Returns - YTD](https://github.com/OpenBB-finance/OpenBB/assets/85772166/22ed2588-1098-4712-aec1-54dd22c324ef)
+
+## Price Performance Bar Chart
+
+The `obb.equity.price.performance` endpoint will create a bar chart over intervals.
+
+```python
+price_performance = obb.equity.price.performance(SPDRS, chart=True)
+price_performance.show()
+```
+
+![Price Performance](https://github.com/OpenBB-finance/OpenBB/assets/85772166/0de3260d-7fce-490b-90e1-bdfa38d6ab23)
+
+### Create Bar Chart
+
+This example uses the `create_bar_chart()` method, which does not replace the existing chart, in `price_performance.chart`.
+It isolates the one-month performance and orients the layout as horizontal.
+
+```python
+new_data = price_performance.to_df().set_index("symbol").multiply(100).reset_index()
+price_performance.charting.create_bar_chart(
+    data=new_data,
+    x="symbol",
+    y="one_month",
+    orientation="h",
+    title="One Month Price Performance",
+    xtitle="Percent (%)"
+)
+```
+
+![Horizonontal Price Performance](https://github.com/OpenBB-finance/OpenBB/assets/85772166/8da01f73-d7a8-4168-846a-9fa9ed6a0e39)
+
+## Create Your Own
+
+This example analyzes the share volume turnover of the S&P 500 Energy Sector constituents, year-to-date.
+
+```python
+symbols = [
+    'XOM',
+    'CVX',
+    'COP',
+    'WMB',
+    'EOG',
+    'KMI',
+    'OKE',
+    'MPC',
+    'PSX',
+    'SLB',
+    'VLO',
+    'BKR',
+    'HES',
+    'TRGP',
+    'EQT',
+    'OXY',
+    'TPL',
+    'FANG',
+    'EXE',
+    'DVN',
+    'HAL',
+    'CTRA',
+    'APA',
+]
+data = obb.equity.price.historical(symbols, start_date="2025-01-01", provider="yfinance")
+create_bar_chart = data.charting.create_bar_chart
+volume = data.to_df().groupby("symbol").sum()["volume"]
+shares = obb.equity.profile(
+    symbols, provider="yfinance"
+).to_df().set_index("symbol")["shares_float"]
+df = volume.to_frame().join(shares)
+df["Turnover"] = (df.volume/df.shares_float).round(4)
+df = df.sort_values(by="Turnover", ascending=False).reset_index()
+create_bar_chart(
+    data=df,
+    x="symbol",
+    y="Turnover",
+    title="S&P Energy Sector YTD Turnover Rate",
+)
+```
+
+![S&P 500 Energy Sector Turnover Rate](https://github.com/OpenBB-finance/OpenBB/assets/85772166/d29a1c17-6d3b-4925-8b7e-f661da404967)

openbb_platform/obbject_extensions/charting/index.md

@@ -0,0 +1,359 @@
+---
+title: OpenBB Charting
+sidebar_position: 1
+description: This page introduces the optional openbb-charting extension.
+keywords:
+- explanation
+- OpenBB Platform
+- Python client
+- Fast API
+- getting started
+- extensions
+- charting
+- view
+- Plotly
+- toolkits
+- community
+- Plotly
+- OpenBBFigure
+- PyWry
+---
+
+import HeadTitle from '@site/src/components/General/HeadTitle.tsx';
+
+<HeadTitle title="OpenBB Charting - Extensions | OpenBB Platform Docs" />
+
+## Overview
+
+The `openbb-charting` extension provides elements for building and displaying interactive charts, tables, dashboards, and more, directly from the OpenBB Platform's Python Interface and FAST API.
+
+It allows users to create a custom view, without any previous experience working with Plotly, from any response served by the OpenBB Platform.
+
+The Python Interface includes a custom [PyWry](https://github.com/OpenBB-finance/pywry) backend for displaying any content, in a WebKit HTML window served over `localhost`. In an IDE setting, they will be rendered inline.
+
+To install, follow the instructions [here](installation). The sections below provide a general explanation of the extension.
+
+## How Does It Work?
+
+It works by extending the `OBBject` class with a new attribute, `charting`. When it is installed, every response from the OpenBB Platform will be equipped with these tools.
+
+For functions that have pre-defined views, it serves as an intermediary between the user request and the response, activated when `chart=True`. When a chart is created, it will populate the existing, `chart`, attribute of the `OBBject`. This is where it is served by the FAST API from the function request. In the Python Interface, charts can be generated post-request, regardless of `chart=True`.
+
+The `chart` attribute in the OBBject contains three items, responses from the API have two:
+
+- `fig`: The OpenBBFigure object - an extended Plotly GraphObjects class. Not included in the API response.
+- `content`: The Plotly JSON representation of the chart - Returned to the API.
+- `format`: The format of the chart - 'plotly' is currently the only charting library.
+
+There is one OBBject class method, `show()`, which will display the contents of the `chart` attribute, if populated.
+
+The new `charting` attribute that binds to the OBBject also has a `show()` method.  This differs in that it overwrites the existing chart, effectively a 'reset' for the view.
+
+The extension has a docstring, and it lists the class methods within `charting`.
+
+```python
+from openbb import obb
+data = obb.equity.price.historical("AAPL")
+data.charting?
+```
+
+```console
+Charting extension.
+
+Methods
+-------
+show
+    Display chart and save it to the OBBject.
+to_chart
+    Redraw the chart and save it to the OBBject, with an optional entry point for Data.
+functions
+    Return a list of Platform commands with charting functions.
+get_params
+    Return the charting parameters for the function the OBBject was created from.
+indicators
+    Return the list of the available technical indicators to use with the `to_chart` method and OHLC+V data.
+table
+    Display an interactive table.
+create_line_chart
+    Create a line chart from external data.
+create_bar_chart
+    Create a bar chart, on a single x-axis with one or more values for the y-axis, from external data.
+```
+
+:::note
+When creating a chart directly from the OpenBB Platform endpoint, chart parameters must be passed as a nested dictionary under the name, `chart_params`.
+
+```python
+chart_params = dict(
+    title="AAPL 50/200 Day EMA",
+    indicators=dict(
+        ema=dict(length=[50,200]),
+    ),
+)
+params = dict(
+    symbol="AAPL",
+    start_date="2022-01-01",
+    provider="yfinance",
+    chart=True,
+    chart_params=chart_params,
+)
+data = obb.equity.price.historical(**params)
+```
+
+`chart_params` are sent in the body of the request when using the API.
+:::
+
+Passing only `chart=True` will return a default view which can be modified and drawn again post-request, via the `OBBject`.
+
+```console
+OBBject
+
+id: 06614d74-7443-7201-8000-a65f358136a3
+results: [{'date': datetime.date(2022, 1, 3), 'open': 177.8300018310547, 'high': 18...
+provider: yfinance
+warnings: None
+chart: {'content': {'data': [{'close': [182.00999450683594, 179.6999969482422, 174....
+extra: {'metadata': {'arguments': {'provider_choices': {'provider': 'yfinance'}, 's...
+```
+
+```python
+data.show()
+```
+
+![candles with ema](https://github.com/OpenBB-finance/OpenBB/assets/85772166/b427d68b-777e-4230-852a-df749c5dbc46)
+
+### No Render
+
+The charts can be created without opening the PyWry window, and this is the default behaviour when `chart=True`.
+With the `charting.show()` and `charting.to_chart()` methods, the default is `render=True`.
+Setting as `False` will return the chart to itself, populating the `chart` attribute of OBBject.
+
+## What Endpoints Have Charts?
+
+The OpenBB Platform router, open_api.json, function signatures, and documentation are all generated based on your specific configuration. When the `openbb-charting` extension is installed, any function found in the "[charting_router](https://github.com/OpenBB-finance/OpenBB/blob/develop/openbb_platform/obbject_extensions/charting/openbb_charting/charting_router.py)" adds `chart: bool = False` to the command on build. For example, `obb.index.price.historical?`
+
+```python
+Signature:
+obb.index.price.historical(
+    symbol: Annotated[Union[str, List[str]], OpenBBCustomParameter(description='Symbol to get data for. Multiple comma separated items allowed for provider(s): cboe, fmp, intrinio, polygon, yfinance.')],
+    ...
+    chart: typing.Annotated[bool, OpenBBCustomParameter(description='Whether to create a chart or not, by default False.')] = False,
+    **kwargs,
+) -> openbb_core.app.model.obbject.OBBject
+```
+
+### Charting Functions
+
+The `charting` attribute of every command output has methods for identifying the charting functions and parameters.
+While able to serve JSON-serializable charts, the `openbb-charting` extension is best-suited for use with the Python Interface. Much of the functionality is realized post-request.
+
+Examine the extension by returning any command at all.
+
+```python
+from openbb import obb
+
+data = obb.equity.price.historical("SPY,QQQ,XLK,BTC-USD", provider="yfinance")
+
+data.charting.functions()
+```
+
+```console
+['crypto_price_historical',
+ 'currency_price_historical',
+ 'economy_fred_series',
+ 'equity_price_historical',
+ 'equity_price_performance',
+ 'etf_historical',
+ 'etf_holdings',
+ 'etf_price_performance',
+ 'index_price_historical',
+ 'technical_adx',
+ 'technical_aroon',
+ 'technical_cones',
+ 'technical_ema',
+ 'technical_hma',
+ 'technical_macd',
+ 'technical_rsi',
+ 'technical_sma',
+ 'technical_wma',
+ 'technical_zlma']
+```
+
+:::tip
+The list above should, as shown here, should not be considered as the source of truth. It's just a sample.
+:::
+
+If the `OBBject` in question has a dedicated charting function associated with it, parameters are detailed by the `get_params()` method.
+
+```console
+EquityPriceHistoricalChartQueryParams
+
+    Parameters
+    ----------
+
+    data : Union[Data, list[Data], NoneType]
+        Filtered versions of the data contained in the original `self.results`.
+        Columns should be the same as the original data.
+        Example use is to reduce the number of columns, or the length of data, to plot.
+
+    title : Union[str, NoneType]
+        Title of the chart.
+
+    target : Union[str, NoneType]
+        The specific column to target.
+        If supplied, this will override the candles and volume parameters.
+
+    multi_symbol : bool
+        Flag to indicate whether the data contains multiple symbols.
+        This is mostly handled automatically, but if the chart fails to generate try setting this to True.
+
+    same_axis : bool
+        If True, forces all data to be plotted on the same axis.
+
+    normalize : bool
+        If True, the data will be normalized and placed on the same axis.
+
+    returns : bool
+        If True, the cumulative returns for the length of the time series will be calculated and plotted.
+
+    candles : bool
+        If True, and OHLC exists, and there is only one symbol in the data, candles will be plotted.
+
+    heikin_ashi : bool
+        If True, and `candles=True`, Heikin Ashi candles will be plotted.
+
+    volume : bool
+        If True, and volume exists, and `candles=True`, volume will be plotted.
+
+    indicators : Union[ChartIndicators, dict[str, dict[str, Any]], NoneType]
+        Indicators to be plotted, formatted as a dictionary.
+        Data containing multiple symbols will ignore indicators.
+        Example:
+            indicators = dict(
+                sma=dict(length=[20,30,50]),
+                adx=dict(length=14),
+                rsi=dict(length=14),
+            )
+```
+
+Not all commands will have the same `chart_params`, and some less than others, but it is always possible to redraw the chart with a different combination post-request. Here's what the default chart is from the output of the command above.
+
+If `chart=True` was not specified, it will need to be created.
+
+```python
+data.charting.to_chart()
+```
+
+![obb.equity.price.historical()](https://github.com/OpenBB-finance/OpenBB/assets/85772166/9231c455-ee1b-47a8-a627-b0034ea52ecd)
+
+The extension recognized that multiple symbols were within the object, and made a determination to display cumulative returns by default.
+
+A candlestick chart will draw only when there is one symbol in the data.
+
+```python
+obb.equity.price.historical(
+    symbol="XLK",
+    start_date="2024-01-01",
+    provider="yfinance",
+    chart=True,
+    chart_params=dict(title="XLK YTD", heikin_ashi=True)
+).show()
+```
+
+![obb.equity.price.historical()](https://github.com/OpenBB-finance/OpenBB/assets/85772166/13af30b3-7298-402d-ac32-1f7700cd08fd)
+
+## Endpoints Without Charts
+
+Most functions do not have dedicated charts. However, it's still possible to generate one automatically. Using the `data` above, we can try passing it through a quantitative analysis command.
+
+```python
+data = obb.equity.price.historical(
+    symbol="XLK",
+    start_date="2023-01-01",
+    provider="yfinance",
+)
+qa = obb.quantitative.rolling.stdev(data.results, target="close")
+
+qa.charting.show(title="XLK Rolling 21 Day Standard Deviation")
+```
+
+![auto chart](https://github.com/OpenBB-finance/OpenBB/assets/85772166/f87a6648-7365-4529-a254-35897af448ca)
+
+## Charts From Any Data
+
+There are methods for creating a generic chart from any external data.
+They will bypass any data contained in the parent object, unless specifically fed into itself.
+
+- charting.create_bar_chart()
+- charting.create_line_chart()
+
+They can also be used as standalone components by initializing an empty instance of the OBBject class.
+
+```python
+from openbb import obb
+from openbb_core.app.model.obbject import OBBject
+create_bar_chart = OBBject(results=None).charting.create_bar_chart
+
+create_bar_chart?
+````
+
+```console
+Create a bar chart on a single x-axis with one or more values for the y-axis.
+
+Parameters
+----------
+data : Union[list, dict, pd.DataFrame, List[pd.DataFrame], pd.Series, List[pd.Series], np.ndarray, Data]
+    Data to plot.
+x : str
+    The x-axis column name.
+y : Union[str, List[str]]
+    The y-axis column name(s).
+barmode : Literal["group", "stack", "relative", "overlay"], optional
+    The bar mode, by default "group".
+xtype : Literal["category", "multicategory", "date", "log", "linear"], optional
+    The x-axis type, by default "category".
+title : Optional[str], optional
+    The title of the chart, by default None.
+xtitle : Optional[str], optional
+    The x-axis title, by default None.
+ytitle : Optional[str], optional
+    The y-axis title, by default None.
+orientation : Literal["h", "v"], optional
+    The orientation of the chart, by default "v".
+colors: Optional[List[str]], optional
+    Manually set the colors to cycle through for each column in 'y', by default None.
+layout_kwargs : Optional[Dict[str, Any]], optional
+    Additional keyword arguments to apply with figure.update_layout(), by default None.
+
+Returns
+-------
+OpenBBFigure
+    The OpenBBFigure object.
+```
+
+## Tables
+
+The `openbb-charting` extension is equipped with interactive tables, utilizing the React framework. They are displayed by using the `table` method.
+
+```python
+data = obb.equity.price.quote("AAPL,MSFT,GOOGL,META,TSLA,AMZN", provider="yfinance")
+data.charting.table()
+```
+
+![Interactive Tables](https://github.com/OpenBB-finance/OpenBB/assets/85772166/77f5f812-b933-4ced-929c-c1e39b2a3eed)
+
+External data can also be supplied, providing an opportunity to filter or apply Pandas operations before display.
+
+```python
+new_df = df.to_df().T
+new_df.index.name="metric"
+new_df.columns = new_df.loc["symbol"]
+new_df.drop("symbol", inplace=True)
+data.charting.table(data=new_df)
+```
+
+![Tables From External Data](https://github.com/OpenBB-finance/OpenBB/assets/85772166/d02f8c34-e1d1-4001-a73e-d3b948a4c5c1)
+
+:::important
+This does not alter the contents of the original object, the displayed data is a copy.
+:::

openbb_platform/obbject_extensions/charting/indicators.md

@@ -0,0 +1,384 @@
+---
+title: Indicators
+sidebar_position: 2
+description: A tutorial of the technical indicators included with the openbb-charting library, including how to get started using them.
+keywords:
+- tutorial
+- OpenBB Platform
+- getting started
+- extensions
+- charting
+- view
+- Plotly
+- toolkits
+- indicators
+- Plotly
+- OpenBBFigure
+- PyWry
+---
+
+import HeadTitle from '@site/src/components/General/HeadTitle.tsx';
+
+<HeadTitle title="Indicators - OpenBB Charting - Extensions | OpenBB Platform Docs" />
+
+## Introduction
+
+Select indicators (technical) can be added to a chart where the data is OHLC+V prices over time, and the data is for one symbol only.
+They are meant as quick visualizations, and a way to build more complex charts.
+As starting points, they can be refined to perfection by manipulating the figure object directly.
+
+```python
+from datetime import datetime, timedelta
+from openbb import obb
+data = obb.equity.price.historical(
+    "TSLA",
+    provider="yfinance",
+    interval="15m",
+    start_date=(datetime.now()-timedelta(days=21)).date(),
+    chart=True,
+    chart_params=dict(
+        heikin_ashi=True,
+        indicators=(dict(
+            ema=dict(length=[8,32]),
+            srlines={}, # For indicators, an empty dictionary implies the default state.
+            rsi=dict(length=32)
+        ))
+    )
+)
+data.show()
+```
+
+![TSLA Intraday With Indicators](https://github.com/OpenBB-finance/OpenBB/assets/85772166/7d8d95d8-0383-4e9d-9477-7ad2424328df)
+
+## Available Indicators
+
+To get all the indicators, use the `charting.indicators()` method.
+The object returned is a Pydantic model where each indicator is field.
+If you don't catch it, it will print as a docstring to the console.
+
+:::danger
+Some indicators, like RSI and MACD, create subplots. Only 4 subplots (not including the main candles + volume) can be created within the same view.
+:::
+
+```python
+data.charting.indicators()
+```
+
+```console
+SMA:
+
+    Parameters
+    ----------
+
+    length : Union[int, list[int]]
+        Window length for the moving average, by default is 50.
+        The number is relative to the interval of the time series data.
+
+    offset : int
+        Number of periods to offset for the moving average, by default is 0.
+
+EMA:
+
+    Parameters
+    ----------
+
+    length : Union[int, list[int]]
+        Window length for the moving average, by default is 50.
+        The number is relative to the interval of the time series data.
+
+    offset : int
+        Number of periods to offset for the moving average, by default is 0.
+
+HMA:
+
+    Parameters
+    ----------
+
+    length : Union[int, list[int]]
+        Window length for the moving average, by default is 50.
+        The number is relative to the interval of the time series data.
+
+    offset : int
+        Number of periods to offset for the moving average, by default is 0.
+
+WMA:
+
+    Parameters
+    ----------
+
+    length : Union[int, list[int]]
+        Window length for the moving average, by default is 50.
+        The number is relative to the interval of the time series data.
+
+    offset : int
+        Number of periods to offset for the moving average, by default is 0.
+
+ZLMA:
+
+    Parameters
+    ----------
+
+    length : Union[int, list[int]]
+        Window length for the moving average, by default is 50.
+        The number is relative to the interval of the time series data.
+
+    offset : int
+        Number of periods to offset for the moving average, by default is 0.
+
+AD:
+
+    Parameters
+    ----------
+
+    offset : int
+        Offset value for the AD, by default is 0.
+
+AD Oscillator:
+
+    Parameters
+    ----------
+
+    fast : int
+        Number of periods to use for the fast calculation, by default 3.
+
+    slow : int
+        Number of periods to use for the slow calculation, by default 10.
+
+    offset : int
+        Offset to be used for the calculation, by default is 0.
+
+ADX:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the ADX, by default is 50.
+
+    scalar : float
+        Scalar to multiply the ADX by, default is 100.
+
+    drift : int
+        Drift value for the ADX, by default is 1.
+
+Aroon:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the Aroon, by default is 50.
+
+    scalar : float
+        Scalar to multiply the Aroon by, default is 100.
+
+ATR:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the ATR, by default is 14.
+
+    mamode : Literal[rma, ema, sma, wma]
+        The mode to use for the moving average calculation.
+
+    drift : int
+        The difference period.
+
+    offset : int
+        Number of periods to offset the result, by default is 0.
+
+CCI:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the CCI, by default is 14.
+
+    scalar : float
+        Scalar to multiply the CCI by, default is 0.015.
+
+Clenow:
+
+    Parameters
+    ----------
+
+    period : int
+        The number of periods for the momentum, by default 90.
+
+Demark:
+
+    Parameters
+    ----------
+
+    show_all : bool
+        Show 1 - 13.
+        If set to False, show 6 - 9.
+
+    offset : int
+        Number of periods to offset the result, by default is 0.
+
+Donchian:
+
+    Parameters
+    ----------
+
+    lower : Union[int, NoneType]
+        Window length for the lower band, by default is 20.
+
+    upper : Union[int, NoneType]
+        Window length for the upper band, by default is 20.
+
+    offset : Union[int, NoneType]
+        Number of periods to offset the result, by default is 0.
+
+Fib:
+
+    Parameters
+    ----------
+
+    period : int
+        The period to calculate the Fibonacci Retracement, by default 120.
+
+    start_date : Union[str, NoneType]
+        The start date for the Fibonacci Retracement.
+
+    end_date : Union[str, NoneType]
+        The end date for the Fibonacci Retracement.
+
+Fisher:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the Fisher Transform, by default is 14.
+
+    signal : int
+        Fisher Signal Period
+
+Ichimoku:
+
+    Parameters
+    ----------
+
+    conversion : int
+        The conversion line period, by default 9.
+
+    base : int
+        The base line period, by default 26.
+
+    lagging : int
+        The lagging line period, by default 52.
+
+    offset : int
+        The offset period, by default 26.
+
+    lookahead : bool
+        Drops the Chikou Span Column to prevent potential data leak
+
+KC:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the Keltner Channel, by default is 20.
+
+    scalar : float
+        Scalar to multiply the ATR, by default is 2.
+
+    mamode : Literal[ema, sma, wma, hna, zlma, rma]
+        The mode to use for the moving average calculation, by default is ema.
+
+    offset : int
+        Number of periods to offset the result, by default is 0.
+
+MACD:
+
+    Parameters
+    ----------
+
+    fast : Union[int, NoneType]
+        Window length for the fast EMA, by default is 12.
+
+    slow : Union[int, NoneType]
+        Window length for the slow EMA, by default is 26.
+
+    signal : Union[int, NoneType]
+        Window length for the signal line, by default is 9.
+
+    scalar : Union[float, NoneType]
+        Scalar to multiply the MACD by, default is 100.
+
+OBV:
+
+    Parameters
+    ----------
+
+    offset : int
+        Number of periods to offset the result, by default is 0.
+
+RSI:
+
+    Parameters
+    ----------
+
+    length : int
+        Window length for the RSI, by default is 14.
+
+    scalar : float
+        Scalar to multiply the RSI by, default is 100.
+
+    drift : int
+        Drift value for the RSI, by default is 1.
+
+SRLines:
+
+    Parameters
+    ----------
+
+    show : bool
+        Show the support and resistance lines.
+
+Stoch:
+
+    Parameters
+    ----------
+
+    fast_k : int
+        The fast K period, by default 14.
+
+    slow_d : int
+        The slow D period, by default 3.
+
+    slow_k : int
+        The slow K period, by default 3.
+```
+
+The model can be converted to a dictionary and then passed through the `indicators` params.
+
+The chart below is built from the same object as the one above.
+
+```python
+indicators = data.charting.indicators().dict()
+macd=indicators.get("macd")
+kc=indicators.get("kc")
+chart_params=dict(
+    candles=False,
+    title="My New Chart",
+    indicators=(dict(
+        macd=macd,
+        kc=kc,
+    ))
+)
+data.charting.to_chart(**chart_params)
+```
+
+![indicators2](https://github.com/OpenBB-finance/OpenBB/assets/85772166/76c06aff-a568-4b7f-80d4-c58a73c0f1d7)
+
+:::tip
+Data can be exported directly from the chart as a CSV. Use the button at the bottom-right of the mode bar.
+:::

openbb_platform/obbject_extensions/charting/installation.md

@@ -0,0 +1,71 @@
+---
+title: Installation
+sidebar_position: 1
+description: This page outlines the installation of the openbb-charting extension.
+keywords:
+- tutorial
+- OpenBB Platform
+- Installation
+- Python client
+- Fast API
+- getting started
+- extensions
+- charting
+- view
+- Plotly
+- toolkit
+- community
+- Plotly
+- OpenBBFigure
+- PyWry
+---
+
+import HeadTitle from '@site/src/components/General/HeadTitle.tsx';
+
+<HeadTitle title="Installation - Charting - Extensions | OpenBB Platform Docs" />
+
+## PyPI
+
+To install the extension, run the following command in this folder:
+
+```bash
+pip install openbb-charting
+```
+
+> Find the latest version on [PyPI](https://pypi.org/project/openbb-charting/).
+
+## Editable Mode
+
+To install from source in editable mode, navigate into the folder, `~/openbb_platform/extensions/charting`, and enter:
+
+```console
+pip install -e .
+```
+
+After installation, the Python interface will automatically rebuild on initialization.  This process can also be triggered manually with:
+
+```python
+import openbb
+openbb.build()
+```
+
+The Python interpreter may need to be restarted.
+
+## PyWry Dependency In Linux
+
+When using Linux distributions, the PyWry dependency requires certain dependencies to be installed first.
+
+- Debian-based / Ubuntu / Mint:
+`sudo apt install libwebkit2gtk-4.0-dev`
+
+- Arch Linux / Manjaro:
+`sudo pacman -S webkit2gtk`
+
+- Fedora:
+`sudo dnf install gtk3-devel webkit2gtk3-devel`
+
+If Rust (Cargo) is required, install it:
+
+```console
+curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh
+```

openbb_platform/obbject_extensions/charting/integration/test_charting_api.py

@@ -0,0 +1,908 @@
+"""Integration tests for charting API."""
+
+import base64
+import json
+
+import pytest
+import requests
+from extensions.tests.conftest import parametrize
+from openbb_core.env import Env
+from openbb_core.provider.utils.helpers import get_querystring
+
+
+@pytest.fixture(scope="session")
+def headers():
+    """Headers fixture."""
+    return get_headers()
+
+
+# pylint:disable=redefined-outer-name
+
+data: dict = {}
+
+
+def get_headers():
+    """Get headers for requests."""
+    if "headers" in data:
+        return data["headers"]
+
+    userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}"
+    userpass_bytes = userpass.encode("ascii")
+    base64_bytes = base64.b64encode(userpass_bytes)
+
+    data["headers"] = {"Authorization": f"Basic {base64_bytes.decode('ascii')}"}
+    return data["headers"]
+
+
+def get_equity_data():
+    """Get equity data."""
+    if "stocks_data" in data:
+        return data["stocks_data"]
+
+    url = "http://0.0.0.0:8000/api/v1/equity/price/historical?symbol=AAPL&provider=fmp"
+    result = requests.get(url, headers=get_headers(), timeout=10)
+    data["stocks_data"] = result.json()["results"]
+
+    return data["stocks_data"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "AAPL",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_equity_price_historical(params, headers):
+    """Test chart equity price historical.."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/equity/price/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=40)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "USDGBP",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_currency_price_historical(params, headers):
+    """Test chart currency price historical."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/currency/price/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=40)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "QQQ",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_etf_historical(params, headers):
+    """Test chart etf historical."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/etf/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=40)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "NDX",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_index_price_historical(params, headers):
+    """Test chart index price historical."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/index/price/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=40)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_crypto_price_historical(params, headers):
+    """Test chart crypto price historical."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/crypto/price/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=40)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "index": "date",
+            "length": "60",
+            "scalar": "90.0",
+            "drift": "2",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_adx(params, headers):
+    """Test chart ta adx."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/adx?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [{"data": "", "index": "date", "length": "30", "scalar": "110", "chart": True}],
+)
+@pytest.mark.integration
+def test_charting_technical_aroon(params, headers):
+    """Test chart ta aroon."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/aroon?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "",
+            "length": "60",
+            "offset": "10",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_ema(params, headers):
+    """Test chart ta ema."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/ema?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "date",
+            "length": "55",
+            "offset": "2",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_hma(params, headers):
+    """Test chart ta hma."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/hma?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "date",
+            "fast": "10",
+            "slow": "30",
+            "signal": "10",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_macd(params, headers):
+    """Test chart ta macd."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/macd?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "date",
+            "length": "16",
+            "scalar": "90.0",
+            "drift": "2",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_rsi(params, headers):
+    """Test chart ta rsi."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/rsi?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "date",
+            "length": "55",
+            "offset": "2",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_sma(params, headers):
+    """Test chart ta sma."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/sma?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "date",
+            "length": "60",
+            "offset": "10",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_wma(params, headers):
+    """Test chart ta wma."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/wma?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "target": "high",
+            "index": "date",
+            "length": "55",
+            "offset": "5",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_zlma(params, headers):
+    """Test chart ta zlma."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/zlma?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "model": "yang_zhang",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_cones(params, headers):
+    """Test chart ta cones."""
+    params = {p: v for p, v in params.items() if v}
+    body = json.dumps(get_equity_data())
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/technical/cones?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "DGS10",
+            "transform": "pc1",
+            "chart": True,
+            "provider": "fred",
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_economy_fred_series(params, headers):
+    """Test chart ta cones."""
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/economy/fred_series?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "study": "price",
+                "benchmark": "SPY",
+                "long_period": 252,
+                "short_period": 21,
+                "window": 21,
+                "trading_periods": 252,
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_relative_rotation(params):
+    params = {p: v for p, v in params.items() if v}
+    data_params = dict(
+        symbol="AAPL,MSFT,GOOGL,AMZN,SPY",
+        provider="yfinance",
+        start_date="2022-01-01",
+        end_date="2024-01-01",
+    )
+    data_query_str = get_querystring(data_params, [])
+    data_url = f"http://0.0.0.0:8000/api/v1/equity/price/historical?{data_query_str}"
+    data_result = requests.get(data_url, headers=get_headers(), timeout=10).json()[
+        "results"
+    ]
+    body = json.dumps({"data": data_result})
+    query_str = get_querystring(params, ["data"])
+    url = f"http://0.0.0.0:8000/api/v1/technical/relative_rotation?{query_str}"
+    result = requests.post(url, headers=get_headers(), timeout=10, data=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "XRT,XLB,XLI,XLH,XLC,XLY,XLU,XLK",
+            "chart": True,
+            "provider": "finviz",
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_equity_price_performance(params, headers):
+    """Test chart equity price performance."""
+    params = {p: v for p, v in params.items() if v}
+    body = (
+        json.dumps(
+            {"extra_params": {"chart_params": {"limit": 4, "orientation": "h"}}}
+        ),
+    )
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/equity/price/performance?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "XRT,XLB,XLI,XLH,XLC,XLY,XLU,XLK",
+            "chart": True,
+            "provider": "fmp",
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_etf_price_performance(params, headers):
+    """Test chart equity price performance."""
+    params = {p: v for p, v in params.items() if v}
+    body = (json.dumps({"extra_params": {"chart_params": {"orientation": "v"}}}),)
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/etf/price_performance?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "XRT",
+            "chart": True,
+            "provider": "fmp",
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_etf_holdings(params, headers):
+    """Test chart etf holdings."""
+    params = {p: v for p, v in params.items() if v}
+    body = (
+        json.dumps(
+            {"extra_params": {"chart_params": {"orientation": "v", "limit": 10}}}
+        ),
+    )
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/etf/holdings?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "econdb",
+                "country": "united_kingdom",
+                "date": None,
+                "chart": True,
+            }
+        ),
+        (
+            {
+                "provider": "fred",
+                "date": "2023-05-10,2024-05-10",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_fixedincome_government_yield_curve(params, headers):
+    """Test chart fixedincome government yield curve."""
+    params = {p: v for p, v in params.items() if v}
+    body = (json.dumps({"extra_params": {"chart_params": {"title": "test chart"}}}),)
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/fixedincome/government/yield_curve?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "provider": "yfinance",
+            "symbol": "ES",
+            "start_date": "2022-01-01",
+            "end_date": "2022-02-01",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_derivatives_futures_historical(params, headers):
+    """Test chart derivatives futures historical."""
+    params = {p: v for p, v in params.items() if v}
+    body = (json.dumps({"extra_params": {"chart_params": {"title": "test chart"}}}),)
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/futures/historical?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "ES",
+                "date": None,
+                "chart": True,
+            }
+        ),
+        (
+            {
+                "provider": "cboe",
+                "symbol": "VX",
+                "date": "2024-06-25",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_derivatives_futures_curve(params, headers):
+    """Test chart derivatives futures curve."""
+    params = {p: v for p, v in params.items() if v}
+    body = (json.dumps({"extra_params": {"chart_params": {"title": "test chart"}}}),)
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/derivatives/futures/curve?{query_str}"
+    result = requests.get(url, headers=headers, timeout=30, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "provider": "fmp",
+            "symbol": "AAPL",
+            "start_date": "2024-01-01",
+            "end_date": "2024-06-30",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_equity_historical_market_cap(params, headers):
+    """Test chart equity historical market cap."""
+    params = {p: v for p, v in params.items() if v}
+    body = (json.dumps({"extra_params": {"chart_params": {"title": "test chart"}}}),)
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/equity/historical_market_cap?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "bls",
+                "symbol": "APUS49D74714,APUS49D74715,APUS49D74716",
+                "start_date": "2014-01-01",
+                "end_date": "2024-07-01",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_economy_survey_bls_series(params, headers):
+    """Test chart economy survey bls series."""
+    params = {p: v for p, v in params.items() if v}
+    body = (json.dumps({"extra_params": {"chart_params": {"title": "test chart"}}}),)
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/economy/survey/bls_series?{query_str}"
+    result = requests.get(url, headers=headers, timeout=10, json=body)
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "method": "pearson",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_econometrics_correlation_matrix(params, headers):
+    """Test chart econometrics correlation matrix."""
+    # pylint:disable=import-outside-toplevel
+    from pandas import DataFrame
+
+    url = "http://0.0.0.0:8000/api/v1/equity/price/historical?symbol=AAPL,MSFT,GOOG&provider=yfinance"
+    result = requests.get(url, headers=headers, timeout=10)
+    df = DataFrame(result.json()["results"])
+    df = df.pivot(index="date", columns="symbol", values="close").reset_index()
+    body = df.to_dict(orient="records")
+
+    params = {p: v for p, v in params.items() if v}
+
+    query_str = get_querystring(params, [])
+    url = f"http://0.0.0.0:8000/api/v1/econometrics/correlation_matrix?{query_str}"
+    result = requests.post(url, headers=headers, timeout=10, data=json.dumps(body))
+
+    assert isinstance(result, requests.Response)
+    assert result.status_code == 200
+
+    chart = result.json()["chart"]
+    fig = chart.pop("fig", {})
+
+    assert chart
+    assert not fig
+    assert list(chart.keys()) == ["content", "format"]

openbb_platform/obbject_extensions/charting/integration/test_charting_python.py

@@ -0,0 +1,747 @@
+"""Test charting extension."""
+
+import pytest
+from extensions.tests.conftest import parametrize
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_core.app.model.obbject import OBBject
+
+
+# pylint:disable=inconsistent-return-statements
+@pytest.fixture(scope="session")
+def obb(pytestconfig):
+    """Fixture to setup obb."""
+    if pytestconfig.getoption("markexpr") != "not integration":
+        import openbb  # pylint:disable=import-outside-toplevel
+
+        return openbb.obb
+
+
+# pylint:disable=redefined-outer-name
+
+data: dict = {}
+
+
+def get_equity_data():
+    """Get equity data."""
+    import openbb  # pylint:disable=import-outside-toplevel
+
+    if "stocks_data" in data:
+        return data["stocks_data"]
+
+    symbol = "AAPL"
+    provider = "fmp"
+
+    data["stocks_data"] = openbb.obb.equity.price.historical(
+        symbol=symbol, provider=provider
+    ).results
+    return data["stocks_data"]
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "AAPL",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_equity_price_historical(params, obb):
+    """Test chart equity price historical."""
+    result = obb.equity.price.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "JPYUSD",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_currency_price_historical(params, obb):
+    """Test chart currency price historical."""
+    result = obb.currency.price.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "BTCUSD",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_crypto_price_historical(params, obb):
+    """Test chart crypto price historical."""
+    result = obb.crypto.price.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "NDX",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_index_price_historical(params, obb):
+    """Test chart index price historical."""
+    result = obb.index.price.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "QQQ",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_etf_historical(params, obb):
+    """Test chart etf historical."""
+    result = obb.etf.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "date",
+                "length": "60",
+                "scalar": "90.0",
+                "drift": "2",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_adx(params, obb):
+    """Test chart ta adx."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.adx(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "index": "date",
+                "length": "30",
+                "scalar": "110",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_aroon(params, obb):
+    """Test chart ta aroon."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.aroon(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "",
+                "length": "60",
+                "offset": "10",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_ema(params, obb):
+    """Test chart ta ema."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.ema(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "date",
+                "length": "55",
+                "offset": "2",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_hma(params, obb):
+    """Test chart ta hma."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.hma(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "date",
+                "fast": "10",
+                "slow": "30",
+                "signal": "10",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_macd(params, obb):
+    """Test chart ta macd."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.macd(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "date",
+                "length": "16",
+                "scalar": "90.0",
+                "drift": "2",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_rsi(params, obb):
+    """Test chart ta rsi."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.rsi(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "date",
+                "length": "55",
+                "offset": "2",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_sma(params, obb):
+    """Test chart ta sma."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.sma(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "date",
+                "length": "60",
+                "offset": "10",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_wma(params, obb):
+    """Test chart ta wma."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.wma(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "target": "high",
+                "index": "date",
+                "length": "55",
+                "offset": "5",
+                "chart": "True",
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_zlma(params, obb):
+    """Test chart ta zlma."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.zlma(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "model": "yang_zhang",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_cones(params, obb):
+    """Test chart ta cones."""
+    params = {p: v for p, v in params.items() if v}
+
+    params["data"] = get_equity_data()
+
+    result = obb.technical.cones(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "DGS10",
+            "transform": "pc1",
+            "chart": True,
+            "provider": "fred",
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_economy_fred_series(params, obb):
+    """Test chart economy fred series."""
+    result = obb.economy.fred_series(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "data": "",
+                "study": "price",
+                "benchmark": "SPY",
+                "long_period": 252,
+                "short_period": 21,
+                "window": 21,
+                "trading_periods": 252,
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_technical_relative_rotation(params, obb):
+    params["data"] = obb.equity.price.historical(
+        "AAPL,MSFT,GOOGL,AMZN,SPY",
+        provider="yfinance",
+        start_date="2022-01-01",
+        end_date="2024-01-01",
+    ).results
+    result = obb.technical.relative_rotation(
+        data=params["data"],
+        benchmark=params["benchmark"],
+        study=params["study"],
+        long_period=params["long_period"],
+        short_period=params["short_period"],
+        window=params["window"],
+        trading_periods=params["trading_periods"],
+        chart=params["chart"],
+    )
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results.rs_ratios) > 0  # type: ignore
+    assert result.chart.content  # type: ignore
+    assert isinstance(result.chart.fig, OpenBBFigure)  # type: ignore
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "XRT,XLB,XLI,XLH,XLC,XLY,XLU,XLK",
+            "chart": True,
+            "provider": "finviz",
+            "chart_params": {"limit": 4, "orientation": "h"},
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_equity_price_performance(params, obb):
+    """Test chart equity price performance."""
+    result = obb.equity.price.performance(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "XRT,XLB,XLI,XLH,XLC,XLY,XLU,XLK",
+            "chart": True,
+            "provider": "fmp",
+            "chart_params": {"orientation": "v"},
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_etf_price_performance(params, obb):
+    """Test chart etf price performance."""
+    result = obb.etf.price_performance(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": None,
+            "symbol": "XRT",
+            "chart": True,
+            "provider": "fmp",
+            "chart_params": {"orientation": "v", "limit": 10},
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_etf_holdings(params, obb):
+    """Test chart etf holdings."""
+    result = obb.etf.holdings(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "econdb",
+                "country": "united_kingdom",
+                "date": None,
+                "chart": True,
+            }
+        ),
+        (
+            {
+                "provider": "fred",
+                "date": "2023-05-10,2024-05-10",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_fixedincome_government_yield_curve(params, obb):
+    """Test chart fixedincome government yield curve."""
+    result = obb.fixedincome.government.yield_curve(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "provider": "yfinance",
+            "symbol": "ES",
+            "start_date": "2022-01-01",
+            "end_date": "2022-02-01",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_derivatives_futures_historical(params, obb):
+    """Test chart derivatives futures historical."""
+    result = obb.derivatives.futures.historical(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "yfinance",
+                "symbol": "ES",
+                "date": None,
+                "chart": True,
+            }
+        ),
+        (
+            {
+                "provider": "cboe",
+                "symbol": "VX",
+                "date": "2024-06-25",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_derivatives_futures_curve(params, obb):
+    """Test chart derivatives futures curve."""
+    result = obb.derivatives.futures.curve(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "fmp",
+                "symbol": "AAPL",
+                "start_date": "2024-01-01",
+                "end_date": "2024-06-30",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_equity_historical_market_cap(params, obb):
+    """Test chart equity historical market cap."""
+    result = obb.equity.historical_market_cap(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        (
+            {
+                "provider": "bls",
+                "symbol": "APUS49D74714,APUS49D74715,APUS49D74716",
+                "start_date": "2014-01-01",
+                "end_date": "2024-07-01",
+                "chart": True,
+            }
+        ),
+    ],
+)
+@pytest.mark.integration
+def test_charting_economy_survey_bls_series(params, obb):
+    """Test chart economy survey bls series."""
+    result = obb.economy.survey.bls_series(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)
+
+
+@parametrize(
+    "params",
+    [
+        {
+            "data": "",
+            "method": "pearson",
+            "chart": True,
+        }
+    ],
+)
+@pytest.mark.integration
+def test_charting_econometrics_correlation_matrix(params, obb):
+    """Test chart econometrics correlation matrix."""
+
+    symbols = "XRT,XLB,XLI,XLH,XLC,XLY,XLU,XLK".split(",")
+    params["data"] = (
+        obb.equity.price.historical(symbol=symbols, provider="yfinance")
+        .to_df()
+        .pivot(columns="symbol", values="close")
+        .filter(items=symbols, axis=1)
+    )
+    result = obb.econometrics.correlation_matrix(**params)
+    assert result
+    assert isinstance(result, OBBject)
+    assert len(result.results) > 0
+    assert result.chart.content
+    assert isinstance(result.chart.fig, OpenBBFigure)

openbb_platform/obbject_extensions/charting/openbb_charting/__init__.py

@@ -0,0 +1,25 @@
+"""OpenBB OBBject extension for charting."""
+
+import warnings
+
+from openbb_core.app.model.extension import Extension
+
+warnings.filterwarnings(
+    "ignore",
+    category=UserWarning,
+    module="openbb_core.app.model.extension",
+)
+
+
+def get_charting_module():
+    """Get the Charting module."""
+    # pylint: disable=import-outside-toplevel
+    import importlib
+
+    _Charting = importlib.import_module("openbb_charting.charting").Charting
+    return _Charting
+
+
+ext = Extension(name="charting", description="Create custom charts from OBBject data.")
+
+Charting = ext.obbject_accessor(get_charting_module())

openbb_platform/obbject_extensions/charting/openbb_charting/charting.py

@@ -0,0 +1,681 @@
+"""Charting Class implementation."""
+
+# pylint: disable=too-many-arguments,unused-argument,too-many-positional-arguments
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+from warnings import warn
+
+from importlib_metadata import entry_points
+from openbb_core.app.model.charts.chart import Chart
+from openbb_core.app.model.obbject import OBBject
+from openbb_core.provider.abstract.data import Data
+
+from openbb_charting.charts.helpers import (
+    get_charting_functions,
+    get_charting_functions_list,
+)
+
+if TYPE_CHECKING:
+    from numpy import ndarray  # noqa
+    from pandas import DataFrame, Series  # noqa
+    from plotly.graph_objs import Figure  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+    from openbb_charting.query_params import ChartParams  # noqa
+    from openbb_charting.core.backend import Backend  # noqa
+
+
+class Charting:
+    """Charting extension.
+
+    Methods
+    -------
+    show
+        Display chart and save it to the OBBject.
+    to_chart
+        Redraw the chart and save it to the OBBject, with an optional entry point for Data.
+    functions
+        Return a list of Platform commands with charting functions.
+    get_params
+        Return the charting parameters for the function the OBBject was created from.
+    indicators
+        Return the list of the available technical indicators to use with the `to_chart` method and OHLC+V data.
+    table
+        Display an interactive table.
+    create_line_chart
+        Create a line chart from external data.
+    create_bar_chart
+        Create a bar chart, on a single x-axis with one or more values for the y-axis, from external data.
+    create_correlation_matrix
+        Create a correlation matrix from external data.
+    toggle_chart_style
+        Toggle the chart style, of an existing chart, between light and dark mode.
+    """
+
+    _extension_views: ClassVar[List[Type]] = [
+        entry_point.load()
+        for entry_point in entry_points(group="openbb_charting_extension")
+    ]
+    _format = "plotly"  # the charts computed by this extension will be in plotly format
+
+    def __init__(self, obbject):
+        """Initialize Charting extension."""
+        # pylint: disable=import-outside-toplevel
+        import importlib  # noqa
+
+        charting_settings_module = importlib.import_module(
+            "openbb_core.app.model.charts.charting_settings", "ChartingSettings"
+        )
+        ChartingSettings = charting_settings_module.ChartingSettings
+
+        self._obbject: OBBject = obbject
+        self._charting_settings = ChartingSettings(
+            user_settings=self._obbject._user_settings,  # type: ignore
+            system_settings=self._obbject._system_settings,  # type: ignore
+        )
+        self._backend = self._handle_backend()
+        self._functions: Dict[str, Callable] = self._get_functions()
+
+    @classmethod
+    def indicators(cls):
+        """Return an instance of the IndicatorsParams class, containing all available indicators and their parameters.
+
+        Without assigning to a variable, it will print the the information to the console.
+        """
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.query_params import IndicatorsParams
+
+        return IndicatorsParams()
+
+    @classmethod
+    def functions(cls) -> List[str]:
+        """Return a list of the available functions."""
+        functions: List[str] = []
+        for view in cls._extension_views:
+            functions.extend(get_charting_functions_list(view))
+
+        return functions
+
+    def _get_functions(self) -> Dict[str, Callable]:
+        """Return a dict with the available functions."""
+        functions: Dict[str, Callable] = {}
+        for view in self._extension_views:
+            functions.update(get_charting_functions(view))
+
+        return functions
+
+    def _handle_backend(self) -> "Backend":
+        """Create and start the backend."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.core.backend import create_backend, get_backend
+
+        create_backend(self._charting_settings)
+        backend = get_backend()
+        backend.start(debug=self._charting_settings.debug_mode)
+        return backend
+
+    def _get_chart_function(self, route: str) -> Callable:
+        """Given a route, it returns the chart function. The module must contain the given route."""
+        if route is None:
+            raise ValueError("OBBject was initialized with no function route.")
+        adjusted_route = route.replace("/", "_")[1:]
+        if adjusted_route not in self._functions:
+            raise ValueError(
+                f"Could not find the route `{adjusted_route}` in the charting functions."
+            )
+        return self._functions[adjusted_route]
+
+    def get_params(self) -> Union["ChartParams", None]:
+        """Return the ChartQueryParams class for the function the OBBject was created from.
+
+        Without assigning to a variable, it will print the docstring to the console.
+        If the class is not defined, the help for the function will be returned.
+        """
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.query_params import ChartParams
+
+        if self._obbject._route is None:  # pylint: disable=protected-access
+            raise ValueError("OBBject was initialized with no function route.")
+        charting_function = (
+            self._obbject._route  # pylint: disable=protected-access
+        ).replace("/", "_")[1:]
+        if hasattr(ChartParams, charting_function):
+            return getattr(ChartParams, charting_function)()
+
+        return help(  # type: ignore
+            self._get_chart_function(  # pylint: disable=protected-access
+                self._obbject.extra[  # pylint: disable=protected-access
+                    "metadata"
+                ].route
+            )
+        )
+
+    def _prepare_data_as_df(
+        self, data: Optional[Union["DataFrame", "Series"]]
+    ) -> Tuple["DataFrame", bool]:
+        """Convert supplied data to a DataFrame."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.app.utils import basemodel_to_df, convert_to_basemodel
+        from pandas import DataFrame, Series
+
+        has_data = (
+            isinstance(data, (Data, DataFrame, Series)) and not data.empty  # type: ignore
+        ) or (bool(data))
+        index = (
+            data.index.name
+            if has_data and isinstance(data, (DataFrame, Series))
+            else None
+        )
+        data_as_df: DataFrame = (
+            basemodel_to_df(convert_to_basemodel(data), index=index)
+            if has_data
+            else self._obbject.to_dataframe(index=index)
+        )
+        if "date" in data_as_df.columns:
+            data_as_df = data_as_df.set_index("date")
+        if "provider" in data_as_df.columns:
+            data_as_df.drop(columns="provider", inplace=True)
+        return data_as_df, has_data
+
+    # pylint: disable=too-many-locals
+    def create_line_chart(
+        self,
+        data: Union[
+            list,
+            dict,
+            "DataFrame",
+            List["DataFrame"],
+            "Series",
+            List["Series"],
+            "ndarray",
+            Data,
+        ],
+        index: Optional[str] = None,
+        target: Optional[str] = None,
+        title: Optional[str] = None,
+        x: Optional[str] = None,
+        xtitle: Optional[str] = None,
+        y: Optional[Union[str, List[str]]] = None,
+        ytitle: Optional[str] = None,
+        y2: Optional[Union[str, List[str]]] = None,
+        y2title: Optional[str] = None,
+        layout_kwargs: Optional[dict] = None,
+        scatter_kwargs: Optional[dict] = None,
+        normalize: bool = False,
+        returns: bool = False,
+        same_axis: bool = False,
+        render: bool = True,
+        **kwargs,
+    ) -> Union["OpenBBFigure", "Figure", None]:
+        """Create a line chart from external data and render a chart or return the OpenBBFigure.
+
+        Parameters
+        ----------
+        data : Union[Data, DataFrame, Series]
+            Data to be plotted (OHLCV data).
+        index : Optional[str], optional
+            Index column, by default None
+        target : Optional[str], optional
+            Target column to be plotted, by default None
+        title : Optional[str], optional
+            Chart title, by default None
+        x : Optional[str], optional
+            X-axis column, by default None
+        xtitle : Optional[str], optional
+            X-axis title, by default None
+        y : Optional[Union[str, List[str]]], optional
+            Y-axis column(s), by default None
+            If None are supplied, the layout is optimized for the contents of data.
+            Where many units/scales are present,
+            it will attempt to divide based on the range of values.
+        ytitle : Optional[str], optional
+            Y-axis title, by default None
+        y2 : Optional[Union[str, List[str]]], optional
+            Y2-axis column(s), by default None
+        y2title : Optional[str], optional
+            Y2-axis title, by default None
+        layout_kwargs : Optional[dict], optional
+            Additional Plotly Layout parameters for `fig.update_layout`, by default None
+        scatter_kwargs : Optional[dict], optional
+            Additional Plotly parameters applied on creation of each scatter plot, by default None
+        normalize : bool, optional
+            Normalize the data with Z-Score Standardization, by default False
+        returns : bool, optional
+            Convert the data to cumulative returns, by default False
+        same_axis: bool, optional
+            If True, forces all data onto the same Y-axis, by default False
+        render: bool, optional
+            If True, the chart will be rendered, by default True
+        **kwargs: Dict[str, Any]
+            Extra parameters to be passed to `figure.show()`
+        """
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.charts.generic_charts import line_chart
+
+        fig = line_chart(
+            data=data,
+            index=index,
+            target=target,
+            title=title,
+            x=x,
+            xtitle=xtitle,
+            y=y,
+            ytitle=ytitle,
+            y2=y2,
+            y2title=y2title,
+            layout_kwargs=layout_kwargs,
+            scatter_kwargs=scatter_kwargs,
+            normalize=normalize,
+            returns=returns,
+            same_axis=same_axis,
+            **kwargs,
+        )
+        fig = self._set_chart_style(fig)
+        if render:
+            return fig.show(**kwargs)
+
+        return fig
+
+    def create_bar_chart(
+        self,
+        data: Union[
+            list,
+            dict,
+            "DataFrame",
+            List["DataFrame"],
+            "Series",
+            List["Series"],
+            "ndarray",
+            Data,
+        ],
+        x: str,
+        y: Union[str, List[str]],
+        barmode: Literal["group", "stack", "relative", "overlay"] = "group",
+        xtype: Literal[
+            "category", "multicategory", "date", "log", "linear"
+        ] = "category",
+        title: Optional[str] = None,
+        xtitle: Optional[str] = None,
+        ytitle: Optional[str] = None,
+        orientation: Literal["h", "v"] = "v",
+        colors: Optional[List[str]] = None,
+        layout_kwargs: Optional[Dict[str, Any]] = None,
+        bar_kwargs: Optional[Dict[str, Any]] = None,
+        render: bool = True,
+        **kwargs,
+    ) -> Union["OpenBBFigure", "Figure", None]:
+        """Create a bar chart on a single x-axis with one or more values for the y-axis.
+
+        Parameters
+        ----------
+        data : Union[list, dict, DataFrame, List[DataFrame], Series, List[Series], ndarray, Data]
+            Data to plot.
+        x : str
+            The x-axis column name.
+        y : Union[str, List[str]]
+            The y-axis column name(s).
+        barmode : Literal["group", "stack", "relative", "overlay"], optional
+            The bar mode, by default "group".
+        xtype : Literal["category", "multicategory", "date", "log", "linear"], optional
+            The x-axis type, by default "category".
+        title : str, optional
+            The title of the chart, by default None.
+        xtitle : str, optional
+            The x-axis title, by default None.
+        ytitle : str, optional
+            The y-axis title, by default None.
+        colors: List[str], optional
+            Manually set the colors to cycle through for each column in 'y', by default None.
+        bar_kwargs : Dict[str, Any], optional
+            Additional keyword arguments to apply with figure.add_bar(), by default None.
+        layout_kwargs : Dict[str, Any], optional
+            Additional keyword arguments to apply with figure.update_layout(), by default None.
+        Returns
+        -------
+        OpenBBFigure
+            The OpenBBFigure object.
+        """
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.charts.generic_charts import bar_chart
+
+        fig = bar_chart(
+            data=data,
+            x=x,
+            y=y,
+            barmode=barmode,
+            xtype=xtype,
+            title=title,
+            xtitle=xtitle,
+            ytitle=ytitle,
+            orientation=orientation,
+            colors=colors,
+            bar_kwargs=bar_kwargs,
+            layout_kwargs=layout_kwargs,
+        )
+        fig = self._set_chart_style(fig)
+        if render:
+            return fig.show(**kwargs)
+
+        return fig
+
+    def create_correlation_matrix(
+        self,
+        data: Union[
+            list[Data],
+            "DataFrame",
+        ],
+        method: Literal["pearson", "kendall", "spearman"] = "pearson",
+        colorscale: str = "RdBu",
+        title: str = "Asset Correlation Matrix",
+        layout_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """Create a correlation matrix from external data.
+
+        Parameters
+        ----------
+        data : Union[list[Data], DataFrame]
+            Input dataset.
+        method : Literal["pearson", "kendall", "spearman"]
+            Method to use for correlation calculation. Default is "pearson".
+                pearson : standard correlation coefficient
+                kendall : Kendall Tau correlation coefficient
+                spearman : Spearman rank correlation
+        colorscale : str
+            Plotly colorscale to use for the heatmap. Default is "RdBu".
+        title : str
+            Title of the chart. Default is "Asset Correlation Matrix".
+        layout_kwargs : Dict[str, Any]
+            Additional keyword arguments to apply with figure.update_layout(), by default None.
+
+        Returns
+        -------
+        OpenBBFigure
+            The OpenBBFigure object.
+        """
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.charts.correlation_matrix import correlation_matrix
+
+        kwargs = {
+            "data": data,
+            "method": method,
+            "colorscale": colorscale,
+            "title": title,
+            "layout_kwargs": layout_kwargs,
+        }
+        fig, _ = correlation_matrix(**kwargs)
+        fig = self._set_chart_style(fig)
+        return fig
+
+    # pylint: disable=inconsistent-return-statements
+    def show(self, render: bool = True, **kwargs):
+        """Display chart and save it to the OBBject."""
+        try:
+            charting_function = self._get_chart_function(
+                self._obbject._route  # pylint: disable=protected-access
+            )
+            kwargs["obbject_item"] = self._obbject.results
+            kwargs["charting_settings"] = self._charting_settings
+            kwargs["standard_params"] = (
+                self._obbject._standard_params  # pylint: disable=protected-access
+            )
+            kwargs["extra_params"] = (
+                self._obbject._extra_params  # pylint: disable=protected-access
+            )
+            kwargs["provider"] = self._obbject.provider
+            kwargs["extra"] = self._obbject.extra
+            fig, content = charting_function(**kwargs)
+            fig = self._set_chart_style(fig)
+            content = fig.show(external=True, **kwargs).to_plotly_json()
+            self._obbject.chart = Chart(fig=fig, content=content, format=self._format)
+            if render:
+                fig.show(**kwargs)
+        except Exception:  # pylint: disable=W0718
+            try:
+                fig = self.create_line_chart(data=self._obbject.results, render=False, **kwargs)  # type: ignore
+                fig = self._set_chart_style(fig)
+                content = fig.show(external=True, **kwargs).to_plotly_json()  # type: ignore
+                self._obbject.chart = Chart(
+                    fig=fig, content=content, format=self._format
+                )
+                if render:
+                    return fig.show(**kwargs)  # type: ignore
+            except Exception as e:
+                raise RuntimeError(
+                    "Failed to automatically create a generic chart with the data provided."
+                ) from e
+
+    # pylint: disable=too-many-locals,inconsistent-return-statements
+    def to_chart(
+        self,
+        data: Optional[
+            Union[
+                list,
+                dict,
+                "DataFrame",
+                List["DataFrame"],
+                "Series",
+                List["Series"],
+                "ndarray",
+                Data,
+            ]
+        ] = None,
+        target: Optional[str] = None,
+        index: Optional[str] = None,
+        indicators: Optional[Dict[str, Dict[str, Any]]] = None,
+        symbol: str = "",
+        candles: bool = True,
+        volume: bool = True,
+        volume_ticks_x: int = 7,
+        render: bool = True,
+        **kwargs,
+    ):
+        """Create an OpenBBFigure with user customizations (if any) and save it to the OBBject.
+
+        This function is used to populate, or re-populate, the OBBject with a chart using the data within
+        the OBBject or external data supplied via the `data` parameter.
+        This function modifies the original OBBject by overwriting the existing chart.
+
+        Parameters
+        ----------
+        data : Union[Data, DataFrame, Series]
+            Data to be plotted.
+        indicators : Dict[str, Dict[str, Any]], optional
+            Indicators to be plotted, by default None
+        symbol : str, optional
+            Symbol to be plotted. This is used for labels and titles, by default ""
+        candles : bool, optional
+            If True, candles will be plotted, by default True
+        volume : bool, optional
+            If True, volume will be plotted, by default True
+        volume_ticks_x : int, optional
+            Volume ticks, by default 7
+        render : bool, optional
+            If True, the chart will be rendered, by default True
+        kwargs: Dict[str, Any]
+            Extra parameters to be passed to the chart constructor.
+
+        Examples
+        --------
+        Plotting a time series with TA indicators
+
+        >>> from openbb import obb
+        >>> res = obb.equity.price.historical("AAPL")
+        >>> indicators = dict(
+        >>>    sma=dict(length=[20,30,50]),
+        >>>    adx=dict(length=14),
+        >>>    rsi=dict(length=14),
+        >>>    macd=dict(fast=12, slow=26, signal=9),
+        >>>    bbands=dict(length=20, std=2),
+        >>>    stoch=dict(length=14),
+        >>>    ema=dict(length=[20,30,50]),
+        >>> )
+        >>> res.charting.to_chart(**{"indicators": indicators})
+
+        Get all the available indicators
+
+        >>> res = obb.equity.price.historical("AAPL")
+        >>> indicators = res.charting.indicators()
+        >>> indicators?
+        """
+        data_as_df, has_data = self._prepare_data_as_df(data)  # type: ignore
+        if target is not None:
+            data_as_df = data_as_df[[target]]
+        kwargs["candles"] = candles
+        kwargs["volume"] = volume
+        kwargs["volume_ticks_x"] = volume_ticks_x
+        kwargs["indicators"] = indicators if indicators else {}
+        kwargs["symbol"] = symbol
+        kwargs["target"] = target
+        kwargs["index"] = index
+        kwargs["obbject_item"] = self._obbject.results
+        kwargs["charting_settings"] = self._charting_settings
+        kwargs["standard_params"] = (
+            self._obbject._standard_params  # pylint: disable=protected-access
+        )
+        kwargs["extra_params"] = (
+            self._obbject._extra_params  # pylint: disable=protected-access
+        )
+        kwargs["provider"] = self._obbject.provider  # pylint: disable=protected-access
+        kwargs["extra"] = self._obbject.extra  # pylint: disable=protected-access
+        try:
+            if has_data:
+                self.show(data=data_as_df, render=render, **kwargs)
+            else:
+                self.show(**kwargs, render=render)
+        except Exception:  # pylint: disable=W0718
+            try:
+                fig = self.create_line_chart(data=data_as_df, render=False, **kwargs)
+                fig = self._set_chart_style(fig)
+                content = fig.show(external=True, **kwargs).to_plotly_json()  # type: ignore
+                self._obbject.chart = Chart(
+                    fig=fig, content=content, format=self._format
+                )
+                if render:
+                    return fig.show(**kwargs)  # type: ignore
+            except Exception as e:  # pylint: disable=W0718
+                raise RuntimeError(
+                    "Failed to automatically create a generic chart with the data provided."
+                ) from e
+
+    def _set_chart_style(self, figure: "Figure"):
+        """Set the user preference for light or dark mode."""
+        style = self._charting_settings.chart_style
+        font_color = "black" if style == "light" else "white"
+        paper_bgcolor = "white" if style == "light" else "black"
+        figure = figure.update_layout(
+            dict(  # pylint: disable=R1735
+                font_color=font_color, paper_bgcolor=paper_bgcolor
+            )
+        )
+        return figure
+
+    def toggle_chart_style(self):
+        """Toggle the chart style between light and dark mode."""
+        if not hasattr(self._obbject.chart, "fig"):
+            raise ValueError(
+                "Error: No chart has been created. Please create a chart first."
+            )
+        current = self._charting_settings.chart_style
+        new = "light" if current == "dark" else "dark"
+        self._charting_settings.chart_style = new
+        figure = self._obbject.chart.fig  # type: ignore[union-attr]
+        updated_figure = self._set_chart_style(figure)
+        self._obbject.chart.fig = updated_figure  # type: ignore[union-attr]
+        self._obbject.chart.content = updated_figure.show(  # type: ignore[union-attr]
+            external=True
+        ).to_plotly_json()
+
+    @staticmethod
+    def _convert_to_string(x):
+        """Sanitize the data for the table."""
+        # pylint: disable=import-outside-toplevel
+        from numpy import isnan
+
+        if isinstance(x, (float, int)) and not isnan(x):
+            return x
+        if isinstance(x, dict):
+            return ", ".join([str(v) for v in x.values()])
+        if isinstance(x, list):
+            if all(isinstance(i, dict) for i in x):
+                return ", ".join(
+                    str(", ".join([str(v) for v in i.values()])) for i in x
+                )
+            return ", ".join([str(i) for i in x])
+
+        return (
+            str(x)
+            .replace("[", "")
+            .replace("]", "")
+            .replace("'{", "")
+            .replace("}'", "")
+            .replace("nan", "")
+        )
+
+    def table(
+        self,
+        data: Optional[Union["DataFrame", "Series"]] = None,
+        title: str = "",
+    ):
+        """Display an interactive table.
+
+        Parameters
+        ----------
+        data : Optional[Union[DataFrame, Series]], optional
+            Data to be plotted, by default None.
+            If no data is provided the OBBject results will be used.
+        title : str, optional
+            Title of the table, by default "".
+        """
+        # pylint: disable=import-outside-toplevel
+        from pandas import RangeIndex
+
+        data_as_df, _ = self._prepare_data_as_df(data)
+        if isinstance(data_as_df.index, RangeIndex):
+            data_as_df.reset_index(inplace=True, drop=True)
+        else:
+            data_as_df.reset_index(inplace=True)
+        for col in data_as_df.columns:
+            data_as_df[col] = data_as_df[col].apply(self._convert_to_string)
+        if self._backend.isatty:
+            try:
+                self._backend.send_table(
+                    df_table=data_as_df,
+                    title=title
+                    or self._obbject._route,  # pylint: disable=protected-access
+                    theme=self._charting_settings.table_style,
+                )
+            except Exception as e:  # pylint: disable=W0718
+                warn(f"Failed to show figure with backend. {e}")
+
+        else:
+            from plotly import optional_imports
+
+            ipython_display = optional_imports.get_module("IPython.display")
+            if ipython_display:
+                ipython_display.display(ipython_display.HTML(data_as_df.to_html()))
+            else:
+                warn("IPython.display is not available.")
+
+    def url(
+        self,
+        url: str,
+        title: str = "",
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+    ):
+        """Return the URL of the chart."""
+        try:
+            self._backend.send_url(url=url, title=title, width=width, height=height)
+        except Exception as e:  # pylint: disable=W0718
+            warn(f"Failed to show figure with backend. {e}")

openbb_platform/obbject_extensions/charting/openbb_charting/charts/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Charting utils."""

openbb_platform/obbject_extensions/charting/openbb_charting/charts/correlation_matrix.py

@@ -0,0 +1,119 @@
+"""Correlation Matrix Chart."""
+
+from typing import TYPE_CHECKING, Any, Union
+
+if TYPE_CHECKING:
+    from plotly.graph_objs import Figure  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+
+
+def correlation_matrix(  # noqa: PLR0912
+    **kwargs,
+) -> tuple[Union["OpenBBFigure", "Figure"], dict[str, Any]]:
+    """Correlation Matrix Chart."""
+    # pylint: disable=import-outside-toplevel
+    from numpy import ones_like, triu  # noqa
+    from openbb_core.app.utils import basemodel_to_df  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure
+    from openbb_charting.core.chart_style import ChartStyle
+    from plotly.graph_objs import Figure, Heatmap, Layout
+    from pandas import DataFrame
+
+    if "data" in kwargs and isinstance(kwargs["data"], DataFrame):
+        corr = kwargs["data"]
+    elif "data" in kwargs and isinstance(kwargs["data"], list):
+        corr = basemodel_to_df(kwargs["data"], index=kwargs.get("index", "date"))  # type: ignore
+    else:
+        corr = basemodel_to_df(
+            kwargs["obbject_item"], index=kwargs.get("index", "date")  # type: ignore
+        )
+    if (
+        "symbol" in corr.columns
+        and len(corr.symbol.unique()) > 1
+        and "close" in corr.columns
+    ):
+        corr = corr.pivot(
+            columns="symbol",
+            values="close",
+        )
+
+    method = kwargs.get("method") or "pearson"
+    corr = corr.corr(method=method, numeric_only=True)
+
+    X = corr.columns.to_list()
+    x_replace = X[-1]
+    Y = X.copy()
+    y_replace = Y[0]
+    X = [x if x != x_replace else "" for x in X]
+    Y = [y if y != y_replace else "" for y in Y]
+    mask = triu(ones_like(corr, dtype=bool))
+    df = corr.mask(mask)
+    title = kwargs.get("title") or "Asset Correlation Matrix"
+    text_color = "white" if ChartStyle().plt_style == "dark" else "black"
+    colorscale = kwargs.get("colorscale") or "RdBu"
+
+    heatmap = Heatmap(
+        z=df,
+        x=X,
+        y=Y,
+        xgap=1,
+        ygap=1,
+        colorscale=colorscale,
+        colorbar=dict(
+            orientation="v",
+            x=0.8,
+            y=0.5,
+            xanchor="left",
+            yanchor="middle",
+            xref="container",
+            yref="paper",
+            len=0.66,
+            bgcolor="rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)",
+        ),
+        text=df.fillna(""),
+        texttemplate="%{text:.4f}",
+        hoverongaps=False,
+        hovertemplate="%{x} - %{y} : %{z:.4f}<extra></extra>",
+    )
+    layout = Layout(
+        title=title,
+        title_x=0.5,
+        xaxis=dict(
+            showgrid=False,
+            showline=False,
+            ticklen=0,
+            domain=[0.03, 1],
+            tickangle=90,
+            automargin=False,
+        ),
+        yaxis=dict(
+            showgrid=False,
+            side="left",
+            autorange="reversed",
+            showline=False,
+            ticklen=0,
+            automargin="height+width+left",
+            tickmode="auto",
+        ),
+        margin=dict(l=10, r=0, t=0, b=10),
+        dragmode="pan",
+    )
+    fig = Figure(data=[heatmap], layout=layout)
+    figure = OpenBBFigure(fig=fig)
+    figure.update_layout(
+        font=dict(color=text_color),
+        paper_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        plot_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+    )
+    layout_kwargs = kwargs.get("layout_kwargs", {})
+
+    if layout_kwargs:
+        figure.update_layout(**layout_kwargs)
+
+    content = figure.show(external=True).to_plotly_json()  # type: ignore
+
+    return figure, content

openbb_platform/obbject_extensions/charting/openbb_charting/charts/generic_charts.py

@@ -0,0 +1,654 @@
+"""Generic Charts Module."""
+
+# pylint: disable=too-many-arguments,unused-argument,too-many-locals, too-many-branches, too-many-lines, too-many-statements, use-dict-literal, broad-exception-caught, too-many-nested-blocks, too-many-positional-arguments
+
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
+
+from openbb_core.app.utils import basemodel_to_df, convert_to_basemodel
+from openbb_core.provider.abstract.data import Data
+
+from openbb_charting.charts.helpers import (
+    calculate_returns,
+    should_share_axis,
+    z_score_standardization,
+)
+from openbb_charting.core.chart_style import ChartStyle
+from openbb_charting.styles.colors import LARGE_CYCLER
+
+if TYPE_CHECKING:
+    from numpy import ndarray  # noqa
+    from pandas import DataFrame, Series  # noqa
+    from plotly.graph_objs import Figure  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+
+
+def line_chart(  # noqa: PLR0912
+    data: Union[
+        list,
+        dict,
+        "DataFrame",
+        List["DataFrame"],
+        "Series",
+        List["Series"],
+        "ndarray",
+        Data,
+    ],
+    index: Optional[str] = None,
+    target: Optional[str] = None,
+    title: Optional[str] = None,
+    x: Optional[str] = None,
+    xtitle: Optional[str] = None,
+    y: Optional[Union[str, List[str]]] = None,
+    ytitle: Optional[str] = None,
+    y2: Optional[Union[str, List[str]]] = None,
+    y2title: Optional[str] = None,
+    layout_kwargs: Optional[dict] = None,
+    scatter_kwargs: Optional[dict] = None,
+    normalize: bool = False,
+    returns: bool = False,
+    same_axis: bool = False,
+    **kwargs,
+) -> Union["OpenBBFigure", "Figure"]:
+    """Create a line chart."""
+    # pylint: disable=import-outside-toplevel
+    from pandas import DataFrame, Series, to_datetime  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure
+
+    if data is None:
+        raise ValueError("Error: Data is a required field.")
+
+    auto_layout = False
+    index = (
+        data.index.name
+        if isinstance(data, (DataFrame, Series))
+        else index if index is not None else x if x is not None else "date"
+    )
+    df: DataFrame = (basemodel_to_df(convert_to_basemodel(data), index=index)).dropna(
+        how="all", axis=1
+    )
+
+    if df.index.name is None:
+        if "date" in df.columns:
+            df.date = df.date.apply(to_datetime)
+            df.set_index("date", inplace=True)
+        else:
+            found_index = False
+            for col in df.columns:
+                if df[col].dtype == "object":
+                    try:
+                        df[col] = df[col].apply(to_datetime)
+                        index = df[col].name  # type: ignore
+                        df.set_index(col, inplace=True)
+                        df.index.name = "date"
+                        found_index = True
+                    except Exception as _:  # noqa: S112
+                        continue
+                if found_index is True:
+                    break
+            if found_index is False:
+                df.set_index(df.iloc[:, 0], inplace=True)
+
+    if "symbol" in df.columns and len(df.symbol.unique()) > 1:
+        df = df.pivot(columns="symbol", values=target if target else "close")
+
+    if "symbol" not in df.columns and target in df.columns:
+        df = df[[target]]
+
+    y = y.split(",") if isinstance(y, str) else y
+
+    if y is None or same_axis is True:
+        y = df.columns.to_list()
+        auto_layout = True
+
+    if same_axis is True:
+        auto_layout = False
+
+    if returns is True:
+        df = df.apply(calculate_returns)
+        auto_layout = False
+
+    if normalize is True:
+        df = df.apply(z_score_standardization)
+        auto_layout = False
+
+    if layout_kwargs is None:
+        layout_kwargs = {}
+
+    if scatter_kwargs is None:
+        scatter_kwargs = {}
+
+    try:
+        fig = OpenBBFigure()
+    except Exception as _:
+        fig = OpenBBFigure(create_backend=True)
+
+    fig.update_layout(ChartStyle().plotly_template.get("layout", {}))
+    text_color = "white" if ChartStyle().plt_style == "dark" else "black"
+    title = f"{title}" if title else ""
+    xtitle = xtitle if xtitle else ""
+    y1title = ytitle if ytitle else ""
+    y2title = y2title if y2title else ""
+    y2 = y2 if y2 else []
+    yaxis_num = 1
+    yaxis = f"y{yaxis_num}"
+    first_y = y[0]  # type: ignore[index]
+    second_y = None
+    third_y = None
+    add_scatter = False
+
+    # Attempt to layout the chart automatically with multiple y-axis.
+    mode = scatter_kwargs.pop("mode", "lines")
+    hovertemplate = scatter_kwargs.pop("hovertemplate", None)
+
+    if auto_layout is True:
+        # Sort columns by the difference between the max and min values.
+        # This is to help determine which columns should share the same y-axis.
+        diff = df.max(numeric_only=True) - df.min(numeric_only=True)
+        sorted_columns = diff.sort_values(ascending=False).index
+        if sorted_columns is None or len(sorted_columns) == 0:
+            raise ValueError("Error: expected data with numeric values.")
+        df = df[sorted_columns]
+
+        for i, col in enumerate(df.columns):
+
+            if col in y:  # type: ignore[operator]
+                hovertemplate = (
+                    hovertemplate
+                    if hovertemplate
+                    else f"{df[col].name}: %{{y}}<extra></extra>"
+                )
+                share_yaxis = should_share_axis(df, first_y, col, threshold=2.5)
+                if share_yaxis is True:
+                    add_scatter = True
+                if share_yaxis is False:
+                    yaxis_num = 2
+                    yaxis = f"y{yaxis_num}"
+                    if second_y is None:
+                        second_y = col
+                        add_scatter = True
+                    if second_y is not None:
+                        add_scatter = False
+                        share_yaxis = should_share_axis(df, col, second_y, threshold=3)
+                        if share_yaxis is True:
+                            add_scatter = True
+                    if share_yaxis is False:
+                        yaxis_num = 3
+                        yaxis = f"y{yaxis_num}"
+                        third_y = col
+                        add_scatter = True
+
+                if add_scatter is True:
+                    fig = fig.add_scatter(
+                        x=df.index,
+                        y=df[col],
+                        name=col,
+                        mode=mode,
+                        line=dict(width=1, color=LARGE_CYCLER[i % len(LARGE_CYCLER)]),
+                        hovertemplate=hovertemplate,
+                        hoverlabel=dict(font_size=10),
+                        yaxis=yaxis,
+                        **scatter_kwargs,
+                    )
+
+    if auto_layout is False:
+        color = 0
+        for i, col in enumerate(y):  # type: ignore[arg-type]
+            hovertemplate = (
+                hovertemplate
+                if hovertemplate
+                else f"{df[col].name}: %{{y}}<extra></extra>"
+            )
+            fig = fig.add_scatter(
+                x=df.index,
+                y=df[col],
+                name=col,
+                mode=mode,
+                line=dict(width=1, color=LARGE_CYCLER[color]),
+                hovertemplate=hovertemplate,
+                hoverlabel=dict(font_size=10),
+                yaxis="y1",
+                **scatter_kwargs,
+            )
+            color += 1
+        if y2:
+            second_y = y2[0]
+            for i, col in enumerate(y2):
+                hovertemplate = (
+                    hovertemplate
+                    if hovertemplate
+                    else f"{df[col].name}: %{{y}}<extra></extra>"
+                )
+                fig = fig.add_scatter(
+                    x=df.index,
+                    y=df[col],
+                    name=col,
+                    mode=mode,
+                    line=dict(width=1, color=LARGE_CYCLER[color]),
+                    hovertemplate=hovertemplate,
+                    hoverlabel=dict(font_size=10),
+                    yaxis="y2",
+                    **scatter_kwargs,
+                )
+                color += 1
+
+    if returns is True:
+        y1title = "Percent"
+        title = f"{title} - Cumulative Returns" if title else "Cumulative Returns"
+
+    if normalize is True:
+        y1title = "Z-Score"
+        title = f"{title} - Z-Score" if title else "Z-Score"
+
+    if not title and target is not None:
+        title = f"{target.replace('_', ' ').title()}"
+
+    fig.update_layout(
+        title=dict(text=title if title else None, x=0.5, font=dict(size=16)),
+        font=dict(color=text_color),
+        paper_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        plot_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        legend=dict(
+            orientation="v",
+            yanchor="top",
+            xanchor="right",
+            y=0.95,
+            x=-0.01,
+            xref="paper",
+            font=dict(size=12),
+            bgcolor=(
+                "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+            ),
+        ),
+        yaxis=(
+            dict(
+                ticklen=0,
+                side="right",
+                title=dict(
+                    text=y1title if ytitle else None, standoff=30, font=dict(size=16)
+                ),
+                tickfont=dict(size=14),
+                anchor="x",
+                showgrid=True,
+                mirror=True,
+                showline=True,
+                zeroline=False,
+                gridcolor="rgba(128,128,128,0.25)",
+            )
+        ),
+        yaxis2=(
+            dict(
+                overlaying="y",
+                side="left",
+                ticklen=0,
+                showgrid=False,
+                showline=True,
+                zeroline=False,
+                mirror=True,
+                title=dict(
+                    text=y2title if y2title else None, standoff=10, font=dict(size=16)
+                ),
+                tickfont=dict(size=14),
+                anchor="x",
+            )
+        ),
+        yaxis3=(
+            dict(
+                overlaying="y",
+                side="left",
+                ticklen=0,
+                position=0,
+                showgrid=False,
+                showline=False,
+                zeroline=False,
+                showticklabels=True,
+                mirror=False,
+                tickfont=dict(size=12, color="rgba(128,128,128,0.75)"),
+                anchor="free",
+            )
+        ),
+        xaxis=dict(
+            ticklen=0,
+            showgrid=True,
+            title=(
+                dict(text=xtitle, standoff=30, font=dict(size=16)) if xtitle else None
+            ),
+            zeroline=False,
+            showline=True,
+            mirror=True,
+            gridcolor="rgba(128,128,128,0.25)",
+            domain=[0.095, 0.95] if third_y else None,
+        ),
+        margin=dict(r=25, l=25) if normalize is False else None,
+        autosize=True,
+        dragmode="pan",
+        hovermode="x",
+    )
+
+    if df.index.name not in ("date", "timestamp"):
+        fig.update_xaxes(type="category")
+
+    if layout_kwargs:
+        fig.update_layout(
+            **layout_kwargs,
+        )
+
+    return fig
+
+
+def bar_chart(  # noqa: PLR0912
+    data: Union[
+        list,
+        dict,
+        "DataFrame",
+        List["DataFrame"],
+        "Series",
+        List["Series"],
+        "ndarray",
+        Data,
+    ],
+    x: str,
+    y: Union[str, List[str]],
+    barmode: Literal["group", "stack", "relative", "overlay"] = "group",
+    xtype: Literal["category", "multicategory", "date", "log", "linear"] = "category",
+    title: Optional[str] = None,
+    xtitle: Optional[str] = None,
+    ytitle: Optional[str] = None,
+    orientation: Literal["h", "v"] = "v",
+    colors: Optional[List[str]] = None,
+    bar_kwargs: Optional[Dict[str, Any]] = None,
+    layout_kwargs: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> Union["OpenBBFigure", "Figure"]:
+    """Create a vertical bar chart on a single x-axis with one or more values for the y-axis.
+
+    Parameters
+    ----------
+    data : Union[
+        list, dict, "DataFrame", List["DataFrame"], "Series", List["Series"], "ndarray", Data
+    ]
+        Data to plot.
+    x : str
+        The x-axis column name.
+    y : Union[str, List[str]]
+        The y-axis column name(s).
+    barmode : Literal["group", "stack", "relative", "overlay"], optional
+        The bar mode, by default "group".
+    xtype : Literal["category", "multicategory", "date", "log", "linear"], optional
+        The x-axis type, by default "category".
+    title : str, optional
+        The title of the chart, by default None.
+    xtitle : str, optional
+        The x-axis title, by default None.
+    ytitle : str, optional
+        The y-axis title, by default None.
+    colors: List[str], optional
+        Manually set the colors to cycle through for each column in 'y', by default None.
+    bar_kwargs : Dict[str, Any], optional
+        Additional keyword arguments to apply with figure.add_bar(), by default None.
+    layout_kwargs : Dict[str, Any], optional
+        Additional keyword arguments to apply with figure.update_layout(), by default None.
+
+    Returns
+    -------
+    OpenBBFigure
+        The OpenBBFigure object.
+    """
+    # pylint: disable=import-outside-toplevel
+    from openbb_charting.core.openbb_figure import OpenBBFigure
+
+    try:
+        figure = OpenBBFigure()
+    except Exception as _:
+        figure = OpenBBFigure(create_backend=True)
+
+    figure = figure.create_subplots(
+        1,
+        1,
+        shared_xaxes=True,
+        vertical_spacing=0.06,
+        horizontal_spacing=0.01,
+        row_width=[1],
+        specs=[[{"secondary_y": True}]],
+    )
+
+    figure.update_layout(ChartStyle().plotly_template.get("layout", {}))
+    text_color = "white" if ChartStyle().plt_style == "dark" else "black"
+    if colors is not None:
+        figure.update_layout(colorway=colors)
+    if bar_kwargs is None:
+        bar_kwargs = {}
+    if isinstance(data, (Data, list, dict)):
+        data = basemodel_to_df(convert_to_basemodel(data), index=None)
+
+    bar_df = data.copy().set_index(x)  # type: ignore
+    y = y.split(",") if isinstance(y, str) else y
+    hovertemplate = bar_kwargs.pop("hovertemplate", None)
+    width = bar_kwargs.pop("width", None)
+    for item in y:
+        figure.add_bar(
+            x=bar_df.index if orientation == "v" else bar_df[item],
+            y=bar_df[item] if orientation == "v" else bar_df.index,
+            name=bar_df[item].name,
+            showlegend=len(y) > 1,
+            legendgroup=bar_df[item].name,
+            orientation=orientation,
+            hovertemplate=(
+                hovertemplate
+                if hovertemplate
+                else (
+                    "%{fullData.name}:%{y}<extra></extra>"
+                    if orientation == "v"
+                    else "%{fullData.name}:%{x}<extra></extra>"
+                )
+            ),
+            width=(
+                width
+                if width
+                else 0.95 / len(y) * 0.75 if barmode == "group" and len(y) > 1 else 0.95
+            ),
+            **bar_kwargs,
+        )
+
+    figure.update_layout(
+        title=dict(text=title if title else None, x=0.5, font=dict(size=16)),
+        paper_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        plot_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rbga(255,255,255,0)"
+        ),
+        legend=dict(
+            orientation="v",
+            yanchor="top",
+            xanchor="right",
+            y=0.95,
+            x=-0.01 if orientation == "v" else 1.01,
+            xref="paper",
+            font=dict(size=12),
+            bgcolor=(
+                "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+            ),
+        ),
+        xaxis=dict(
+            type=xtype,
+            title=dict(
+                text=xtitle if xtitle else None, standoff=30, font=dict(size=16)
+            ),
+            ticklen=0,
+            showgrid=orientation == "h",
+            tickfont=dict(size=12, family="sans-serif"),
+            categoryorder="array" if orientation == "v" else None,
+            categoryarray=bar_df.index if orientation == "v" else None,
+        ),
+        yaxis=dict(
+            title=dict(
+                text=ytitle if ytitle else None, standoff=30, font=dict(size=16)
+            ),
+            ticklen=0,
+            showgrid=orientation == "v",
+            tickfont=dict(size=12),
+            side="left" if orientation == "h" else "right",
+            categoryorder="array" if orientation == "h" else None,
+            categoryarray=bar_df.index if orientation == "h" else None,
+        ),
+        margin=dict(pad=5),
+        barmode=barmode,
+        font=dict(color=text_color),
+    )
+    if orientation == "h":
+        figure.update_layout(
+            xaxis=dict(
+                type="linear",
+                showspikes=False,
+            ),
+            yaxis=dict(
+                type="category",
+                showspikes=False,
+            ),
+            hoverlabel=dict(
+                font=dict(size=12),
+            ),
+            hovermode="y unified",
+        )
+    if layout_kwargs:
+        figure.update_layout(
+            **layout_kwargs,
+        )
+    return figure
+
+
+def bar_increasing_decreasing(  # pylint: disable=W0102
+    keys: List[str],
+    values: List[Union[int, float]],
+    title: Optional[str] = None,
+    xtitle: Optional[str] = None,
+    ytitle: Optional[str] = None,
+    colors: List[str] = ["blue", "red"],
+    orientation: Literal["h", "v"] = "h",
+    barmode: Literal["group", "stack", "relative", "overlay"] = "relative",
+    layout_kwargs: Optional[Dict[str, Any]] = None,
+) -> Union["OpenBBFigure", "Figure"]:
+    """Create a bar chart with increasing and decreasing values represented by two colors.
+
+    Parameters
+    ----------
+    keys : List[str]
+        The x-axis keys.
+    values : List[Any]
+        The y-axis values.
+    title : Optional[str], optional
+        The title of the chart, by default None.
+    xtitle : Optional[str], optional
+        The x-axis title, by default None.
+    ytitle : Optional[str], optional
+        The y-axis title, by default None.
+    colors : List[str], optional
+        The colors to use for increasing and decreasing values, by default ["blue", "red"].
+    orientation : Literal["h", "v"], optional
+        The orientation of the bars, by default "h".
+    barmode : Literal["group", "stack", "relative", "overlay"], optional
+        The bar mode, by default "relative".
+    layout_kwargs : Optional[Dict[str, Any]], optional
+        Additional keyword arguments to apply with figure.update_layout(), by default None.
+
+    Returns
+    -------
+    OpenBBFigure
+        The OpenBBFigure object.
+    """
+    # pylint: disable=import-outside-toplevel
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+    from pandas import Series
+
+    try:
+        figure = OpenBBFigure()
+    except Exception as _:
+        figure = OpenBBFigure(create_backend=True)
+
+    figure = figure.create_subplots(
+        1,
+        1,
+        shared_xaxes=False,
+        vertical_spacing=0.06,
+        horizontal_spacing=0.01,
+        row_width=[1],
+        specs=[[{"secondary_y": True}]],
+    )
+    figure.update_layout(ChartStyle().plotly_template.get("layout", {}))
+    text_color = "white" if ChartStyle().plt_style == "dark" else "black"
+
+    try:
+        data = Series(data=values, index=keys)
+        increasing_data = data[data > 0]  # type: ignore
+        decreasing_data = data[data < 0]  # type: ignore
+    except Exception as e:
+        raise ValueError(f"Error: {e}") from e
+
+    if not increasing_data.empty:
+        figure.add_bar(
+            x=increasing_data.index if orientation == "v" else increasing_data,
+            y=increasing_data if orientation == "v" else increasing_data.index,
+            marker=dict(color=colors[0]),
+            orientation=orientation,
+            showlegend=False,
+            width=0.95 / len(keys) * 0.75 if barmode == "group" else 0.95,
+            hoverinfo="y" if orientation == "v" else "x",
+        )
+    if not decreasing_data.empty:
+        figure.add_bar(
+            x=decreasing_data.index if orientation == "v" else decreasing_data,
+            y=decreasing_data if orientation == "v" else decreasing_data.index,
+            marker=dict(color=colors[1]),
+            orientation=orientation,
+            showlegend=False,
+            width=0.95 / len(keys) * 0.75 if barmode == "group" else 0.95,
+            hoverinfo="y" if orientation == "v" else "x",
+        )
+
+    figure.update_layout(
+        title=dict(text=title if title else None, x=0.5, font=dict(size=20)),
+        hovermode="x" if orientation == "v" else "y",
+        hoverlabel=dict(align="left" if orientation == "h" else "auto"),
+        yaxis=dict(
+            title=dict(
+                text=ytitle if ytitle else None, standoff=30, font=dict(size=16)
+            ),
+            side="left" if orientation == "h" else "right",
+            showgrid=orientation == "v",
+            gridcolor="rgba(128,128,128,0.25)",
+            tickfont=dict(size=12),
+            ticklen=0,
+            categoryorder="array" if orientation == "h" else None,
+            categoryarray=keys if orientation == "h" else None,
+        ),
+        xaxis=dict(
+            title=dict(
+                text=xtitle if xtitle else None, standoff=30, font=dict(size=16)
+            ),
+            showgrid=orientation == "h",
+            gridcolor="rgba(128,128,128,0.25)",
+            tickfont=dict(size=12),
+            ticklen=0,
+            categoryorder="array" if orientation == "v" else None,
+            categoryarray=keys if orientation == "v" else None,
+        ),
+        paper_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        plot_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        font=dict(color="white" if text_color == "white" else "black"),
+        margin=dict(pad=5),
+    )
+
+    if layout_kwargs:
+        figure.update_layout(
+            **layout_kwargs,
+        )
+
+    return figure

openbb_platform/obbject_extensions/charting/openbb_charting/charts/helpers.py

@@ -0,0 +1,123 @@
+"""Helper functions for charting."""
+
+# pylint: disable=R0917
+
+from typing import TYPE_CHECKING, Callable, Dict, List, Type
+
+if TYPE_CHECKING:
+    from pandas import DataFrame, Series
+
+
+def get_charting_functions(view: Type) -> Dict[str, Callable]:
+    """Discover charting functions."""
+    # pylint: disable=import-outside-toplevel
+    from inspect import getmembers, getsource, isfunction
+
+    implemented_functions: Dict[str, Callable] = {}
+
+    for name, obj in getmembers(view, isfunction):
+        if (
+            obj.__module__ == view.__module__
+            and not name.startswith("_")
+            and "NotImplementedError" not in getsource(obj)
+        ):
+            implemented_functions[name] = obj
+
+    return implemented_functions
+
+
+def get_charting_functions_list(view: Type) -> List[str]:
+    """Get a list of all the charting functions."""
+    return list(get_charting_functions(view).keys())
+
+
+def z_score_standardization(data: "Series") -> "Series":
+    """Z-Score Standardization Method."""
+    return (data - data.mean()) / data.std()
+
+
+def calculate_returns(data: "Series") -> "Series":
+    """Calculate the returns of a column."""
+    return ((1 + data.pct_change(fill_method=None).fillna(0)).cumprod() - 1) * 100
+
+
+def should_share_axis(
+    df: "DataFrame", col1: str, col2: str, threshold: float = 0.15
+) -> bool:
+    """Determine whether two columns should share an axis."""
+    # pylint: disable=import-outside-toplevel
+    from pandas import Series
+
+    try:
+        if isinstance(df, Series):
+            df = df.to_frame()
+        range1 = df[col1].max() - df[col1].min()
+        range2 = df[col2].max() - df[col2].min()
+        # Calculate the ratio of the two ranges
+        ratio = max(range1, range2) / min(range1, range2)
+        # If the ratio is less than the threshold, the two columns can share an axis
+        if ratio == 1:
+            return True
+        return ratio < threshold
+    except Exception:
+        return False
+
+
+def heikin_ashi(data: "DataFrame") -> "DataFrame":
+    """Return OHLC data as Heikin Ashi Candles.
+
+    Parameters
+    ----------
+    data: DataFrame
+        DataFrame containing OHLC data.
+
+    Returns
+    -------
+    DataFrame
+        DataFrame copy with Heikin Ashi candle calculations.
+    """
+    # pylint: disable=import-outside-toplevel
+    from pandas_ta import candles
+
+    df = data.copy()
+
+    check_columns = ["open", "high", "low", "close"]
+
+    for item in check_columns:
+        if item not in df.columns:
+            raise ValueError(
+                "The expected column labels, "
+                f"{check_columns}"
+                ", were not found in DataFrame."
+            )
+
+    ha = candles.ha(
+        df["open"],
+        df["high"],
+        df["low"],
+        df["close"],
+    )
+
+    for item in check_columns:
+        df[item] = ha[f"HA_{item}"]
+
+    return df
+
+
+def duration_sorter(durations: list) -> list:
+    """Sort durations labeled as month_5, year_5, etc."""
+
+    def duration_to_months(duration):
+        """Convert duration to months."""
+        if duration == "long_term":
+            return 360
+        parts = duration.split("_")
+        months = 0
+        for i in range(0, len(parts), 2):
+            number = int(parts[i + 1])
+            if parts[i] == "year":
+                number *= 12  # Convert years to months
+            months += number
+        return months
+
+    return sorted(durations, key=duration_to_months)

openbb_platform/obbject_extensions/charting/openbb_charting/charts/price_historical.py

@@ -0,0 +1,335 @@
+"""Price historical charting utility."""
+
+# pylint: disable=too-many-branches, too-many-locals, unused-argument
+
+
+from typing import TYPE_CHECKING, Any, Dict, Tuple
+
+from openbb_charting.styles.colors import LARGE_CYCLER
+
+if TYPE_CHECKING:
+    from openbb_charting.core.openbb_figure import OpenBBFigure
+
+
+def price_historical(  # noqa: PLR0912
+    **kwargs,
+) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Equity Price Historical Chart."""
+    # pylint: disable=import-outside-toplevel
+    from pandas import DataFrame  # noqa
+    from openbb_core.app.utils import basemodel_to_df  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+    from openbb_charting.core.plotly_ta.ta_class import PlotlyTA  # noqa
+    from openbb_charting.core.chart_style import ChartStyle  # noqa
+    from openbb_charting.charts.helpers import (  # noqa
+        calculate_returns,
+        heikin_ashi,
+        should_share_axis,
+        z_score_standardization,
+    )
+
+    if "data" in kwargs and isinstance(kwargs["data"], DataFrame):
+        data = kwargs["data"]
+    elif "data" in kwargs and isinstance(kwargs["data"], list):
+        data = basemodel_to_df(kwargs["data"], index=kwargs.get("index", "date"))  # type: ignore
+    else:
+        data = basemodel_to_df(
+            kwargs["obbject_item"], index=kwargs.get("index", "date")  # type: ignore
+        )
+
+    if "date" in data.columns:
+        data = data.set_index("date")
+
+    target = str(kwargs.get("target"))
+    normalize = kwargs.get("normalize") is True
+    returns = kwargs.get("returns") is True
+    same_axis = kwargs.get("same_axis") is True
+    text_color = "black" if ChartStyle().plt_style == "light" else "white"
+    title = f"{kwargs.get('title')}" if "title" in kwargs else "Historical Prices"
+    y1title = ""
+    y2title = ""
+    candles = True
+    multi_symbol = (
+        bool(kwargs.get("multi_symbol") is True)
+        or (
+            "symbol" in data.columns
+            and target in data.columns
+            and len(data.symbol.unique()) > 1
+        )
+        or ("target" in kwargs and kwargs.get("target") is not None)
+        or "symbol" in data.columns
+        or (
+            "symbol" not in data.columns
+            and bool(data.columns.isin(["open", "high", "low", "close"]).all())
+        )
+    )
+    target = "close" if target is None or target == "None" or target == "" else target
+
+    if multi_symbol is True:
+        if "symbol" not in data.columns and target in data.columns:
+            data = data[[target]]
+            y1title = target.title()
+        if "symbol" in data.columns and target in data.columns:
+            data = data.pivot(columns="symbol", values=target)
+            y1title = target
+            title = f"Historical {target.title()}"
+
+    indicators = kwargs.get("indicators", {})
+    candles = bool(~data.columns.isin(["open", "high", "low", "close"]).all())
+    candles = candles if kwargs.get("candles", True) else False
+    volume = kwargs.get("volume", True) if "volume" in data.columns else False
+
+    if normalize is True:
+        if "symbol" not in data.columns and target in data.columns:
+            data = data[[target]]
+        multi_symbol = True
+        candles = False
+        volume = False
+
+    if returns is True:
+        if "symbol" not in data.columns and target in data.columns:
+            data = data[[target]]
+        multi_symbol = True
+        candles = False
+        volume = False
+    if (  # pylint: disable = R0916
+        multi_symbol is False
+        and normalize is False
+        and returns is False
+        and candles is True
+    ) or (indicators and multi_symbol is False):
+        if (
+            "heikin_ashi" in kwargs
+            and kwargs["heikin_ashi"] is True
+            and candles is True
+        ):
+            data = heikin_ashi(data)
+            title = f"{title} - Heikin Ashi"
+        _volume = False
+        if "atr" in indicators:  # type: ignore
+            _volume = volume
+            volume = False
+        ta = PlotlyTA()
+        fig = ta.plot(  # type: ignore
+            data,
+            indicators=indicators if indicators else {},  # type: ignore
+            symbol=target if candles is False else "",
+            candles=candles,
+            volume=volume,  # type: ignore
+        )
+        if _volume is True and "atr" in indicators:  # type: ignore
+            fig.add_inchart_volume(data)
+        fig.update_layout(
+            paper_bgcolor=(
+                "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+            ),
+            plot_bgcolor=(
+                "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+            ),
+            font=dict(color=text_color),
+            showlegend=True,
+            legend=dict(
+                orientation="v",
+                yanchor="top",
+                xanchor="right",
+                y=0.95,
+                x=-0.01,
+                xref="paper",
+                font=dict(size=12),
+                bgcolor=(
+                    "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+                ),
+            ),
+            xaxis=dict(
+                ticklen=0,
+                showgrid=True,
+                gridcolor="rgba(128,128,128,0.3)",
+                zeroline=True,
+                mirror=True,
+                showline=True,
+            ),
+            xaxis2=dict(
+                ticklen=0,
+                showgrid=True,
+                gridcolor="rgba(128,128,128,0.3)",
+                zeroline=True,
+                mirror=True,
+                showline=True,
+            ),
+            yaxis=dict(
+                ticklen=0,
+                showgrid=True,
+                gridcolor="rgba(128,128,128,0.3)",
+                zeroline=True,
+                mirror=True,
+                showline=True,
+                tickfont=dict(size=14),
+            ),
+            yaxis2=dict(
+                ticklen=0,
+                gridcolor="rgba(128,128,128,0.3)",
+            ),
+            yaxis3=dict(
+                ticklen=0,
+                gridcolor="rgba(128,128,128,0.3)",
+            ),
+            dragmode="pan",
+            hovermode="x",
+        )
+
+        if kwargs.get("title"):
+            title = kwargs["title"]
+        fig.update_layout(title=dict(text=title, x=0.5))
+
+        content = fig.to_plotly_json()
+
+        return fig, content
+
+    if multi_symbol is True or candles is False:
+
+        if "symbol" not in data.columns and target in data.columns:
+            data = data[[target]]
+
+        if "symbol" in data.columns:
+            data = data.pivot(columns="symbol", values=target)
+
+        title: str = kwargs.get("title", "Historical Prices")  # type: ignore
+
+        y1title = data.iloc[:, 0].name
+        y2title = ""
+
+        if len(data.columns) > 2 or normalize is True or returns is True:
+            if returns is True or (len(data.columns) > 2 and normalize is False):
+                data = data.apply(calculate_returns)
+                title = f"{title} - Cumulative Returns"
+                y1title = "Percent"
+            if normalize is True:
+                if returns is True:
+                    title = f"{title.replace(' - Cumulative Returns', '')} - Normalized Cumulative Returns"
+                else:
+                    title = title + " - Normalized"
+                data = data.apply(z_score_standardization)
+                y1title = None  # type: ignore
+                y2title = None  # type: ignore
+
+        fig = OpenBBFigure()
+        fig.update_layout(ChartStyle().plotly_template.get("layout", {}))
+        text_color = "white" if ChartStyle().plt_style == "dark" else "black"
+
+        for i, col in enumerate(data.columns):
+
+            hovertemplate = f"{data[col].name}: %{{y}}<extra></extra>"
+            yaxis = "y1"
+            if y1title and y1title != "Percent":
+                yaxis = (
+                    (
+                        "y1"
+                        if should_share_axis(data, col, y1title)  # type: ignore
+                        or col == y1title
+                        or normalize is True
+                        or returns is True
+                        else "y2"
+                    )
+                    if same_axis is False
+                    else "y1"
+                )
+
+            if yaxis == "y2":
+                y2title = data[col].name
+
+            fig.add_scatter(
+                x=data.index,
+                y=data[col],
+                name=data[col].name,
+                mode="lines",
+                hovertemplate=hovertemplate,
+                line=dict(width=2, color=LARGE_CYCLER[i % len(LARGE_CYCLER)]),
+                yaxis=yaxis,
+            )
+
+    if normalize is True or returns is True:
+        y1title = "Percent" if returns is True else None  # type: ignore
+        y2title = None  # type: ignore
+
+    if same_axis is True:
+        y1title = None  # type: ignore
+        y2title = None  # type: ignore
+
+    fig.update_layout(
+        paper_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        plot_bgcolor=(
+            "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+        ),
+        legend=(
+            dict(
+                orientation="v",
+                yanchor="top",
+                xanchor="right",
+                y=0.95,
+                x=-0.01,
+                bgcolor=(
+                    "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+                ),
+            )
+            if len(data.columns) > 2
+            else dict(
+                orientation="h",
+                yanchor="bottom",
+                xanchor="right",
+                y=1.02,
+                x=0.98,
+                bgcolor=(
+                    "rgba(0,0,0,0)" if text_color == "white" else "rgba(255,255,255,0)"
+                ),
+            )
+        ),
+        yaxis1=(
+            dict(
+                side="right",
+                ticklen=0,
+                showgrid=True,
+                showline=True,
+                mirror=True,
+                gridcolor="rgba(128,128,128,0.3)",
+                title=dict(
+                    text=y1title if y1title else None, standoff=20, font=dict(size=20)
+                ),
+                tickfont=dict(size=14),
+                anchor="x",
+            )
+        ),
+        yaxis2=(
+            dict(
+                overlaying="y",
+                side="left",
+                ticklen=0,
+                showgrid=False,
+                title=dict(
+                    text=y2title if y2title else None, standoff=10, font=dict(size=20)
+                ),
+                tickfont=dict(size=14),
+                anchor="x",
+            )
+            if y2title
+            else None
+        ),
+        xaxis=dict(
+            ticklen=0,
+            showgrid=True,
+            gridcolor="rgba(128,128,128,0.3)",
+            showline=True,
+            mirror=True,
+        ),
+        margin=dict(l=20, r=20, b=20, t=20),
+        dragmode="pan",
+        hovermode="x",
+    )
+    if kwargs.get("title"):
+        title = kwargs["title"]
+    fig.update_layout(title=dict(text=title, x=0.5))
+
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content

openbb_platform/obbject_extensions/charting/openbb_charting/charts/price_performance.py

@@ -0,0 +1,108 @@
+"""Price performance charting implementation."""
+
+from typing import TYPE_CHECKING, Any, Dict, Tuple, Union
+
+if TYPE_CHECKING:
+    from plotly.graph_objs import Figure  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+
+
+def price_performance(
+    **kwargs,
+) -> Tuple[Union["OpenBBFigure", "Figure"], Dict[str, Any]]:  # noqa: PLR0912
+    """Equity Price Performance Chart."""
+    # pylint: disable=import-outside-toplevel
+    from pandas import DataFrame  # noqa
+    from openbb_core.app.utils import basemodel_to_df  # noqa
+    from openbb_charting.charts.generic_charts import bar_chart  # noqa
+
+    if "data" in kwargs and isinstance(kwargs["data"], DataFrame):
+        data = kwargs["data"]
+    elif "data" in kwargs and isinstance(kwargs["data"], list):
+        data = basemodel_to_df(kwargs["data"], index=kwargs.get("index", "symbol"))  # type: ignore
+    else:
+        data = basemodel_to_df(
+            kwargs["obbject_item"], index=kwargs.get("index", "symbol")  # type: ignore
+        )
+
+    cols = [
+        "one_day",
+        "one_week",
+        "one_month",
+        "three_month",
+        "six_month",
+        "ytd",
+        "one_year",
+        "two_year",
+        "three_year",
+        "four_year",
+        "five_year",
+    ]
+
+    df = DataFrame()
+    chart_df = DataFrame()
+
+    if "symbol" in data.columns:
+        data = data.set_index("symbol")
+    chart_cols = []
+
+    if len(data) == 0:
+        raise ValueError("No data was found in the DataFrame.")
+
+    data = data.drop_duplicates(keep="first")
+
+    for col in cols:
+        if col in data.columns and data[col].notnull().any():
+            df[col.replace("_", " ").title() if col != "ytd" else col.upper()] = data[
+                col
+            ].apply(lambda x: round(x * 100, 4) if x is not None else None)
+
+    if df.empty:
+        raise ValueError(f"No columns matching, {cols}, were found in the data.")
+
+    chart_df = df.T
+    chart_cols = chart_df.columns.to_list()
+
+    if "limit" in kwargs and isinstance(kwargs.get("limit"), int):
+        limit = kwargs.pop("limit", 10)
+        chart_df = chart_df.head(limit)  # type: ignore
+
+    layout_kwargs: Dict[str, Any] = kwargs.get("layout_kwargs", {})
+
+    title = (
+        f"{kwargs.pop('title')}" if "title" in kwargs else "Equity Price Performance"
+    )
+    orientation = (
+        kwargs.pop("orientation")
+        if "orientation" in kwargs and kwargs.get("orientation") is not None
+        else "v"
+    )
+
+    ytitle = "Performance (%)"
+    xtitle = None
+
+    if orientation == "h":
+        xtitle = ytitle  # type: ignore
+        ytitle = None  # type: ignore
+
+    fig = bar_chart(
+        chart_df.reset_index(),
+        x="index",
+        y=chart_cols,
+        title=title,
+        xtitle=xtitle,
+        ytitle=ytitle,
+        orientation=orientation,  # type: ignore
+    )
+    fig.update_traces(
+        hovertemplate=(
+            "%{fullData.name}:%{y:.2f}%<extra></extra>"
+            if orientation == "v"
+            else "%{fullData.name}:%{x:.2f}%<extra></extra>"
+        )
+    )
+
+    fig.update_layout(**layout_kwargs)
+    content = fig.show(external=True).to_plotly_json()  # type: ignore
+
+    return fig, content

openbb_platform/obbject_extensions/charting/openbb_charting/charts/relative_rotation.py

@@ -0,0 +1,674 @@
+"""Relative Rotation Chart Helpers."""
+
+# pylint: disable=R0917
+
+from datetime import date as dateType
+from typing import TYPE_CHECKING, Literal, Optional
+from warnings import warn
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+    from plotly.graph_objects import Figure
+
+color_sequence = [
+    "burlywood",
+    "orange",
+    "grey",
+    "magenta",
+    "cyan",
+    "yellowgreen",
+    "#1f77b4",
+    "#aec7e8",
+    "#ff7f0e",
+    "#ffbb78",
+    "#d62728",
+    "#ff9896",
+    "#9467bd",
+    "#c5b0d5",
+    "#8c564b",
+    "#c49c94",
+    "#e377c2",
+    "#f7b6d2",
+    "#7f7f7f",
+    "#c7c7c7",
+    "#bcbd22",
+    "#dbdb8d",
+    "#17becf",
+    "#9edae5",
+    "#7e7e7e",
+    "#1b9e77",
+    "#d95f02",
+    "#7570b3",
+    "#e7298a",
+    "#66a61e",
+    "#e6ab02",
+    "#a6761d",
+    "#666666",
+    "#f0027f",
+    "#bf5b17",
+    "#d9f202",
+    "#8dd3c7",
+    "#ffffb3",
+    "#bebada",
+    "#fb8072",
+    "#80b1d3",
+    "#fdb462",
+    "#b3de69",
+    "#fccde5",
+    "#d9d9d9",
+    "#bc80bd",
+    "#ccebc5",
+    "#ffed6f",
+    "#6a3d9a",
+    "#b15928",
+    "#b2df8a",
+    "#33a02c",
+    "#fb9a99",
+    "#e31a1c",
+    "#fdbf6f",
+    "#ff7f00",
+    "#cab2d6",
+    "#6a3d9a",
+    "#ffff99",
+    "#b15928",
+]
+
+
+def create_rrg_with_tails(
+    ratios_data: "DataFrame",
+    momentum_data: "DataFrame",
+    study: str,
+    benchmark_symbol: str,
+    tail_periods: int,
+    tail_interval: Literal["day", "week", "month"],
+) -> "Figure":
+    """Create The Relative Rotation Graph With Tails.
+
+    Parameters
+    ----------
+    ratios_data : DataFrame
+        The DataFrame containing the RS-Ratio values.
+    momentum_data : DataFrame
+        The DataFrame containing the RS-Momentum values.
+    study : str
+        The study that was selected when loading the raw data.
+        If custom data is supplied, this will override the study for the chart titles.
+    benchmark_symbol : str
+        The symbol of the benchmark.
+    tail_periods : int
+        The number of periods to display in the tails.
+    tail_interval : Literal["day", "week", "month"]
+
+    Returns
+    -------
+    Figure
+        Plotly GraphObjects Figure.
+    """
+    # pylint: disable=import-outside-toplevel
+    from pandas import to_datetime
+    from plotly import graph_objects as go
+
+    symbols = ratios_data.columns.to_list()
+
+    tail_dict = {"week": "W", "month": "ME"}
+    ratios_data.index = to_datetime(ratios_data.index)
+    momentum_data.index = to_datetime(momentum_data.index)
+
+    if tail_interval != "day":
+        ratios_data = ratios_data.resample(tail_dict[tail_interval]).last()
+        momentum_data = momentum_data.resample(tail_dict[tail_interval]).last()
+    ratios_data = ratios_data.iloc[-tail_periods:]
+    momentum_data = momentum_data.iloc[-tail_periods:]
+    _tail_periods = len(ratios_data)
+    tail_title = (
+        f"The Previous {_tail_periods} {tail_interval.capitalize()}s "
+        f"Ending {ratios_data.index[-1].strftime('%Y-%m-%d')}"
+    )
+    x_min = ratios_data.min().min()
+    x_max = ratios_data.max().max()
+    y_min = momentum_data.min().min()
+    y_max = momentum_data.max().max()
+    # Create an empty list to store the scatter traces
+    frames: list = []
+    x_data = ratios_data
+    y_data = momentum_data
+    for i, date in enumerate(ratios_data.index):  # pylint: disable=unused-variable
+
+        frame_data: list = []
+
+        for j, symbol in enumerate(symbols):
+            x_frame_data = x_data[symbol].iloc[: i + 1]
+            y_frame_data = y_data[symbol].iloc[: i + 1]
+            name = symbol.upper().replace("^", "").replace(":US", "")
+            special_name = "-" in name or len(name) > 7
+            marker_size = 34 if special_name else 30
+            line_frame_trace = go.Scatter(
+                x=x_frame_data,
+                y=y_frame_data,
+                mode="markers+lines",
+                line=dict(color=color_sequence[j], width=2, dash="dash"),
+                marker=dict(
+                    size=5, color=color_sequence[j], line=dict(color="black", width=1)
+                ),
+                showlegend=False,
+                opacity=0.3,
+                name=name,
+                text=name,
+                hovertemplate="<b>%{fullData.name}</b>: "
+                + "RS-Ratio: %{x:.4f}, "
+                + "RS-Momentum: %{y:.4f}"
+                + "<extra></extra>",
+                hoverlabel=dict(font_size=10),
+            )
+
+            marker_frame_trace = go.Scatter(
+                x=[x_frame_data.iloc[-1]],
+                y=[y_frame_data.iloc[-1]],
+                mode="markers+text",
+                name=name,
+                text=name,
+                textposition="middle center",
+                textfont=(
+                    dict(size=10, color="black")
+                    if len(symbol) < 4
+                    else dict(size=7, color="black")
+                ),
+                line=dict(color=color_sequence[j], width=2, dash="dash"),
+                marker=dict(
+                    size=marker_size,
+                    color=color_sequence[j],
+                    line=dict(color="black", width=1),
+                ),
+                opacity=0.9,
+                showlegend=False,
+                hovertemplate="<b>%{fullData.name}</b>: RS-Ratio: %{x:.4f}, RS-Momentum: %{y:.4f}<extra></extra>",
+            )
+
+            frame_data.extend([line_frame_trace, marker_frame_trace])
+
+        frames.append(go.Frame(data=frame_data, name=f"Frame {i}"))
+
+    # Define the initial trace for the figure
+    initial_trace = frames[0]["data"]
+
+    padding = 0.1
+    y_range = [y_min - padding * abs(y_min) - 0.3, y_max + padding * abs(y_max) + 0.3]
+    x_range = [x_min - padding * abs(x_min) - 0.3, x_max + padding * abs(x_max) + 0.3]
+
+    # Create the layout for the figure
+    layout = go.Layout(
+        title={
+            "text": (
+                f"Relative Rotation Against {benchmark_symbol.replace('^', '')} {study.capitalize()} For {tail_title}"
+            ),
+            "x": 0.5,
+            "xanchor": "center",
+            "font": dict(size=18),
+        },
+        xaxis=dict(
+            title=dict(text="RS-Ratio", font=dict(size=16)),
+            showgrid=True,
+            zeroline=True,
+            showline=True,
+            mirror=True,
+            ticklen=0,
+            zerolinecolor="black",
+            range=x_range,
+            gridcolor="lightgrey",
+            showspikes=False,
+        ),
+        yaxis=dict(
+            title=dict(text="RS-Momentum", font=dict(size=16)),
+            showgrid=True,
+            zeroline=True,
+            showline=True,
+            mirror=True,
+            ticklen=0,
+            zerolinecolor="black",
+            range=y_range,
+            gridcolor="lightgrey",
+            side="left",
+            title_standoff=5,
+        ),
+        plot_bgcolor="rgba(255,255,255,1)",
+        shapes=[
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=0,
+                y0=0,
+                x1=x_range[1],
+                y1=y_range[1],
+                fillcolor="lightgreen",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=x_range[0],
+                y0=0,
+                x1=0,
+                y1=y_range[1],
+                fillcolor="lightblue",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=x_range[0],
+                y0=y_range[0],
+                x1=0,
+                y1=0,
+                fillcolor="lightpink",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=0,
+                y0=y_range[0],
+                x1=x_range[1],
+                y1=0,
+                fillcolor="lightyellow",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=x_range[0],
+                y0=y_range[0],
+                x1=x_range[1],
+                y1=y_range[1],
+                line=dict(
+                    color="Black",
+                    width=1,
+                ),
+                fillcolor="rgba(0,0,0,0)",
+                layer="above",
+            ),
+        ],
+        annotations=[
+            go.layout.Annotation(
+                x=1,
+                xref="paper",
+                y=1,
+                yref="paper",
+                text="Leading",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="darkgreen",
+                ),
+            ),
+            go.layout.Annotation(
+                x=1,
+                xref="paper",
+                y=0,
+                yref="paper",
+                text="Weakening",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="goldenrod",
+                ),
+            ),
+            go.layout.Annotation(
+                x=0,
+                xref="paper",
+                y=0,
+                yref="paper",
+                text="Lagging",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="red",
+                ),
+            ),
+            go.layout.Annotation(
+                x=0,
+                xref="paper",
+                yref="paper",
+                y=1,
+                text="Improving",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="blue",
+                ),
+            ),
+        ],
+        autosize=True,
+        margin=dict(
+            l=30,
+            r=50,
+            b=50,
+            t=50,
+            pad=0,
+        ),
+        dragmode="pan",
+        hovermode="closest",
+        updatemenus=[
+            {
+                "buttons": [
+                    {
+                        "args": [
+                            None,
+                            {
+                                "frame": {"duration": 500, "redraw": False},
+                                "fromcurrent": True,
+                                "transition": {"duration": 500, "easing": "linear"},
+                            },
+                        ],
+                        "label": "Play",
+                        "method": "animate",
+                    }
+                ],
+                "direction": "left",
+                "pad": {"r": 0, "t": 75},
+                "showactive": False,
+                "type": "buttons",
+                "x": -0.025,
+                "xanchor": "left",
+                "y": 0,
+                "yanchor": "top",
+                "bgcolor": "rgba(150, 150, 150, 0.8)",
+                "bordercolor": "rgba(100, 100, 100, 0.5)",
+                "borderwidth": 1,
+                "font": {"color": "black"},
+            }
+        ],
+        sliders=[
+            {
+                "active": 0,
+                "yanchor": "top",
+                "xanchor": "center",
+                "currentvalue": {
+                    "font": {"size": 16},
+                    "prefix": "Date: ",
+                    "visible": True,
+                    "xanchor": "right",
+                },
+                "transition": {"duration": 300, "easing": "cubic-in-out"},
+                "pad": {"b": 10, "t": 50},
+                "len": 0.9,
+                "x": 0.5,
+                "y": 0,
+                "steps": [
+                    {
+                        "label": f"{x_data.index[i].strftime('%Y-%m-%d')}",
+                        "method": "animate",
+                        "args": [
+                            [f"Frame {i}"],
+                            {
+                                "mode": "immediate",
+                                "transition": {"duration": 300},
+                                "frame": {"duration": 300, "redraw": False},
+                            },
+                        ],
+                    }
+                    for i in range(len(x_data.index))
+                ],
+            }
+        ],
+    )
+
+    # Create the figure and add the initial trace
+    fig = go.Figure(data=initial_trace, layout=layout, frames=frames)
+
+    return fig
+
+
+def create_rrg_without_tails(
+    ratios_data: "DataFrame",
+    momentum_data: "DataFrame",
+    benchmark_symbol: str,
+    study: str,
+    date: Optional[dateType] = None,
+) -> "Figure":
+    """Create the Plotly Figure Object without Tails.
+
+    Parameters
+    ----------
+    ratios_data : DataFrame
+        The DataFrame containing the RS-Ratio values.
+    momentum_data : DataFrame
+        The DataFrame containing the RS-Momentum values.
+    benchmark_symbol : str
+        The symbol of the benchmark.
+    study: str
+        The study that was selected when loading the raw data.
+        If custom data is supplied, this will override the study for the chart titles.
+    date : Optional[dateType], optional
+        A specific date within the data to target for display, by default None.
+
+    Returns
+    -------
+    Figure
+        Plotly GraphObjects Figure.
+    """
+    # pylint: disable=import-outside-toplevel
+    from plotly import graph_objects as go  # noqa
+    from pandas import to_datetime  # noqa
+
+    if date is not None and date not in ratios_data.index.astype(str):
+        warn(f"Date {str(date)} not found in data, using the last available date.")
+        date = ratios_data.index[-1]
+    if date is None:
+        date = ratios_data.index[-1]
+
+    # Select a single row from each dataframe
+    row_x = ratios_data.loc[to_datetime(date).date()]  # type: ignore
+    row_y = momentum_data.loc[to_datetime(date).date()]  # type: ignore
+
+    x_max = row_x.max() + 0.5
+    x_min = row_x.min() - 0.5
+    y_max = row_y.max() + 0.5
+    y_min = row_y.min() - 0.5
+
+    # Create an empty list to store the scatter traces
+    traces = []
+
+    # Loop through each column in the row_x dataframe
+    for i, (column_name, value_x) in enumerate(row_x.items()):
+        # Retrieve the corresponding value from the row_y dataframe
+        value_y = row_y[column_name]  # type: ignore
+        marker_name = column_name.upper().replace("^", "").replace(":US", "")  # type: ignore
+        special_name = "-" in marker_name or len(marker_name) > 5
+        marker_size = 38 if special_name else 30
+        # Create a scatter trace for each column
+        trace = go.Scatter(
+            x=[value_x],
+            y=[value_y],
+            mode="markers+text",
+            text=[marker_name],
+            textposition="middle center",
+            textfont=dict(size=10 if len(marker_name) < 4 else 8, color="black"),
+            marker=dict(
+                size=marker_size,
+                color=color_sequence[i % len(color_sequence)],
+                line=dict(color="black", width=1),
+            ),
+            name=column_name,
+            showlegend=False,
+            hovertemplate="<b>%{fullData.name}</b>"
+            + "<br>RS-Ratio: %{x:.4f}</br>"
+            + "RS-Momentum: %{y:.4f}"
+            + "<extra></extra>",
+        )
+        # Add the trace to the list
+        traces.append(trace)
+
+    padding = 0.1
+    y_range = [y_min - padding * abs(y_min) - 0.3, y_max + padding * abs(y_max)]
+    x_range = [x_min - padding * abs(x_min), x_max + padding * abs(x_max)]
+
+    layout = go.Layout(
+        title={
+            "text": (
+                f"RS-Ratio vs RS-Momentum of {study.capitalize()} "
+                f"Against {benchmark_symbol.replace('^', '')} - {to_datetime(row_x.name).strftime('%Y-%m-%d')}"  # type: ignore
+            ),
+            "x": 0.5,
+            "xanchor": "center",
+            "font": dict(size=20),
+        },
+        xaxis=dict(
+            title="RS-Ratio",
+            zerolinecolor="black",
+            range=x_range,
+            showspikes=False,
+        ),
+        yaxis=dict(
+            title="<br>RS-Momentum",
+            zerolinecolor="black",
+            range=y_range,
+            side="left",
+            title_standoff=5,
+            showspikes=False,
+        ),
+        shapes=[
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=0,
+                y0=0,
+                x1=x_range[1],
+                y1=y_range[1],
+                fillcolor="lightgreen",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=x_range[0],
+                y0=0,
+                x1=0,
+                y1=y_range[1],
+                fillcolor="lightblue",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=x_range[0],
+                y0=y_range[0],
+                x1=0,
+                y1=0,
+                fillcolor="lightpink",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=0,
+                y0=y_range[0],
+                x1=x_range[1],
+                y1=0,
+                fillcolor="lightyellow",
+                opacity=0.3,
+                layer="below",
+                line_width=0,
+            ),
+            go.layout.Shape(
+                type="rect",
+                xref="x",
+                yref="y",
+                x0=x_range[0],
+                y0=y_range[0],
+                x1=x_range[1],
+                y1=y_range[1],
+                line=dict(
+                    color="Black",
+                    width=1,
+                ),
+                fillcolor="rgba(0,0,0,0)",
+                layer="above",
+            ),
+        ],
+        annotations=[
+            go.layout.Annotation(
+                x=1,
+                xref="paper",
+                y=1,
+                yref="paper",
+                text="Leading",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="darkgreen",
+                ),
+            ),
+            go.layout.Annotation(
+                x=1,
+                xref="paper",
+                y=0,
+                yref="paper",
+                text="Weakening",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="goldenrod",
+                ),
+            ),
+            go.layout.Annotation(
+                x=0,
+                xref="paper",
+                y=0,
+                yref="paper",
+                text="Lagging",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="red",
+                ),
+            ),
+            go.layout.Annotation(
+                x=0,
+                xref="paper",
+                yref="paper",
+                y=1,
+                text="Improving",
+                showarrow=False,
+                font=dict(
+                    size=18,
+                    color="blue",
+                ),
+            ),
+        ],
+        autosize=True,
+        margin=dict(
+            l=30,
+            r=50,
+            b=50,
+            t=50,
+            pad=0,
+        ),
+        dragmode="pan",
+    )
+
+    fig = go.Figure(data=traces, layout=layout)
+
+    return fig

openbb_platform/obbject_extensions/charting/openbb_charting/core/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Charting core."""

openbb_platform/obbject_extensions/charting/openbb_charting/core/backend.py

@@ -0,0 +1,445 @@
+"""Backend for Plotly."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
+
+if TYPE_CHECKING:
+    from openbb_core.app.model.charts.charting_settings import ChartingSettings
+    from pandas import DataFrame
+    from plotly.graph_objs import Figure
+
+PLOTS_CORE_PATH = Path(__file__).parent.resolve()
+PLOTLYJS_PATH = PLOTS_CORE_PATH / "assets" / "plotly-3.0.0.min.js"
+BACKEND = None
+
+try:
+    from pywry import PyWry  # pylint: disable=import-outside-toplevel
+except ImportError:
+    from .dummy_backend import DummyBackend  # pylint: disable=import-outside-toplevel
+
+    class PyWry(DummyBackend):  # type: ignore
+        """Dummy backend for charts."""
+
+
+class Backend(PyWry):
+    """Custom backend for Plotly."""
+
+    def __new__(cls, *args, **kwargs):  # pylint: disable=W0613
+        """Create a singleton instance of the backend."""
+        if not hasattr(cls, "instance"):
+            cls.instance = super().__new__(cls)  # pylint: disable=E1120
+        return cls.instance
+
+    def __init__(
+        self,
+        charting_settings: "ChartingSettings",
+        daemon: bool = True,
+        max_retries: int = 30,
+        proc_name: str = "OpenBB Platform",
+    ):
+        """Create a new instance of the backend."""
+        # pylint: disable=import-outside-toplevel
+        import atexit  # noqa
+        import sys  # noqa
+        from multiprocessing import current_process  # noqa
+        from packaging import version  # noqa
+
+        self.charting_settings = charting_settings
+        has_version = hasattr(PyWry, "__version__")
+        init_kwargs: Dict[str, Any] = dict(daemon=daemon, max_retries=max_retries)
+
+        if has_version and version.parse(PyWry.__version__) >= version.parse("0.4.8"):
+            init_kwargs.update(dict(proc_name=proc_name))
+
+        super().__init__(**init_kwargs)
+
+        try:
+            from IPython import get_ipython  # pylint: disable=import-outside-toplevel
+
+            if "IPKernelApp" not in get_ipython().config:
+                raise ImportError("console")
+            if (
+                "parent_header"
+                in get_ipython().kernel._parent_ident  # pylint: disable=protected-access
+            ):
+                raise ImportError("notebook")
+        except (ImportError, AttributeError):
+            JUPYTER_NOTEBOOK = False
+        else:
+            JUPYTER_NOTEBOOK = True
+
+        self.plotly_html: Path = (PLOTS_CORE_PATH / "plotly.html").resolve()
+        self.table_html: Path = (PLOTS_CORE_PATH / "table.html").resolve()
+        self.isatty = (
+            not JUPYTER_NOTEBOOK
+            and sys.stdin.isatty()
+            and current_process().name == "MainProcess"
+        )
+        if has_version and PyWry.__version__ == "0.0.0":
+            self.isatty = False
+
+        self.WIDTH, self.HEIGHT = 1400, 762
+        self.logged_in: bool = False
+
+        atexit.register(self.close)
+
+    def set_window_dimensions(self):
+        """Set the window dimensions."""
+        width = 1400
+        height = 762
+
+        self.WIDTH, self.HEIGHT = int(width), int(height)
+
+    def get_pending(self) -> list:
+        """Get the pending data that has not been sent to the backend."""
+        # pylint: disable=W0201,E0203
+        pending = self.outgoing + self.init_engine
+        self.outgoing: list = []
+        self.init_engine: list = []
+        return pending
+
+    def get_plotly_html(self) -> Path:
+        """Get the plotly html file."""
+        # pylint: disable=import-outside-toplevel
+        import warnings
+
+        self.set_window_dimensions()
+        if self.plotly_html.exists():
+            return self.plotly_html
+
+        warnings.warn(
+            "[bold red]plotly.html file not found, check the path:[/]"
+            f"[green]{PLOTS_CORE_PATH / 'plotly.html'}[/]"
+        )
+        self.max_retries = 0  # pylint: disable=W0201
+        raise FileNotFoundError
+
+    def get_table_html(self) -> Path:
+        """Get the table html file."""
+        # pylint: disable=import-outside-toplevel
+        import warnings
+
+        self.set_window_dimensions()
+        if self.table_html.exists():
+            return self.table_html
+        warnings.warn(
+            "[bold red]table.html file not found, check the path:[/]"
+            f"[green]{PLOTS_CORE_PATH / 'table.html'}[/]"
+        )
+        self.max_retries = 0  # pylint: disable=W0201
+        raise FileNotFoundError
+
+    def get_window_icon(self) -> Optional[Path]:
+        """Get the window icon."""
+        icon_path = PLOTS_CORE_PATH / "assets" / "Terminal_icon.png"
+        if icon_path.exists():
+            return icon_path
+        return None
+
+    def get_json_update(
+        self,
+        cmd_loc: Optional[str] = None,
+        theme: Optional[str] = None,
+    ) -> dict:
+        """Get the json update for the backend."""
+        if self.charting_settings.user_uuid and not self.logged_in:
+            self.logged_in = True
+
+        return dict(
+            theme=theme or self.charting_settings.chart_style,
+            log_id=self.charting_settings.app_id,
+            pywry_version=self.__version__,
+            platform_version=self.charting_settings.version,
+            python_version=self.charting_settings.python_version,
+            command_location=cmd_loc,
+        )
+
+    def send_figure(
+        self,
+        fig: "Figure",
+        export_image: Optional[Union[Path, str]] = "",
+        command_location: Optional[str] = "",
+    ):
+        """Send a Plotly figure to the backend.
+
+        Parameters
+        ----------
+        fig : Figure
+            Plotly figure to send to backend.
+        export_image : str, optional
+            Path to export image to, by default ""
+        command_location : str, optional
+            Location of the command, by default "".
+            We can use the route here to display it on the chart title.
+        """
+        # pylint: disable=import-outside-toplevel
+        import asyncio
+        import json
+        import re
+
+        self.check_backend()
+        # pylint: disable=C0415
+
+        paper_bg = (
+            "rgba(0,0,0,0)"
+            if self.charting_settings.chart_style == "dark"
+            else "rgba(255,255,255,0)"
+        )
+        title = "OpenBB Platform"
+        fig.layout.title.text = re.sub(
+            r"<[^>]*>", "", fig.layout.title.text if fig.layout.title.text else title
+        )
+        fig.layout.height += 69
+
+        export_image = Path(export_image).resolve() if export_image else None
+
+        json_data = json.loads(fig.to_json())
+        json_data.update(self.get_json_update(command_location))
+        json_data["layout"]["paper_bgcolor"] = paper_bg
+
+        outgoing = dict(
+            html=self.get_plotly_html(),
+            json_data=json_data,
+            export_image=export_image,
+            **self.get_kwargs(command_location),
+        )
+        self.send_outgoing(outgoing)
+
+        if export_image:
+            if self.loop.is_closed():  # type: ignore[has-type]
+                # Create a new event loop
+                self.loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(self.loop)
+
+            self.loop.run_until_complete(self.process_image(export_image))
+
+    async def process_image(self, export_image: Path):
+        """Check if the image has been exported to the path."""
+        # pylint: disable=import-outside-toplevel
+        import asyncio
+        import subprocess
+        import sys
+
+        img_path = export_image.resolve()
+
+        checks = 0
+        while not img_path.exists():
+            await asyncio.sleep(0.2)
+            checks += 1
+            if checks > 50:
+                break
+
+        if img_path.exists():  # noqa: SIM102
+            opener = "open" if sys.platform == "darwin" else "xdg-open"
+            subprocess.check_call([opener, export_image])  # nosec: B603 # noqa: S603
+
+    def send_table(  # pylint: disable=too-many-positional-arguments
+        self,
+        df_table: "DataFrame",
+        title: str = "",
+        source: str = "",
+        theme: str = "dark",
+        command_location: Optional[str] = "",
+    ):
+        """Send table data to the backend to be displayed in a table.
+
+        Parameters
+        ----------
+        df_table : DataFrame
+            Dataframe to send to backend.
+        title : str, optional
+            Title to display in the window, by default ""
+        source : str, optional
+            Source of the data, by default ""
+        theme : light or dark, optional
+            Theme of the table, by default "light"
+        """
+        # pylint: disable=import-outside-toplevel
+        import json
+        import re
+
+        self.check_backend()
+
+        if title:
+            # We remove any html tags and markdown from the title
+            title = re.sub(r"<[^>]*>", "", title)
+            title = re.sub(r"\[\/?[a-z]+\]", "", title)
+
+        # we get the length of each column using the max length of the column
+        # name and the max length of the column values as the column width
+        columnwidth = [
+            max(
+                len(str(df_table[col].name)),
+                df_table[col].astype(str).str.len().max(),
+            )
+            for col in df_table.columns
+            if hasattr(df_table[col], "name") and hasattr(df_table[col], "dtype")
+        ]
+
+        # we add a percentage of max to the min column width
+        columnwidth = [
+            int(x + (max(columnwidth) - min(columnwidth)) * 0.2) for x in columnwidth
+        ]
+
+        # in case of a very small table we set a min width
+        width = max(int(min(sum(columnwidth) * 9.7, self.WIDTH + 100)), 800)
+
+        json_data = json.loads(df_table.to_json(orient="split", date_format="iso"))
+        json_data.update(
+            dict(
+                title=title,
+                source=source or "",
+                **self.get_json_update(command_location, theme or "dark"),
+            )
+        )
+
+        outgoing = dict(
+            html=self.get_table_html(),
+            json_data=json.dumps(json_data),
+            width=width,
+            height=self.HEIGHT - 100,
+            **self.get_kwargs(command_location),
+        )
+        self.send_outgoing(outgoing)
+
+    def send_url(
+        self,
+        url: str,
+        title: str = "",
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+    ):
+        """Send a URL to the backend to be displayed in a window.
+
+        Parameters
+        ----------
+        url : str
+            URL to display in the window.
+        title : str, optional
+            Title to display in the window, by default ""
+        width : int, optional
+            Width of the window, by default 1200
+        height : int, optional
+            Height of the window, by default 800
+        """
+        self.check_backend()
+        script = f"""
+        <script>
+            window.location.replace("{url}");
+        </script>
+        """
+        outgoing = dict(
+            html=script,
+            **self.get_kwargs(title),
+            width=width or self.WIDTH,
+            height=height or self.HEIGHT,
+        )
+        self.send_outgoing(outgoing)
+
+    def get_kwargs(self, title: Optional[str] = "") -> dict:
+        """Get the kwargs for the backend."""
+        return {
+            "title": "OpenBB Platform" + (f" - {title}" if title else ""),
+            "icon": self.get_window_icon(),
+            "download_path": str(self.charting_settings.user_exports_directory),
+        }
+
+    def start(self, debug: bool = False, headless: bool = False):
+        """Start the backend WindowManager process."""
+        if self.isatty:
+            super().start(debug, headless)
+
+    def check_backend(self):
+        """Override to check if isatty."""
+        # pylint: disable=import-outside-toplevel
+        import warnings  # noqa
+        from packaging import version  # noqa
+
+        if not self.isatty:
+            return None
+
+        message = (
+            "[bold red]PyWry version 0.5.12 or higher is required to use the "
+            "OpenBB Plots backend.[/]\n"
+            "[yellow]Please update pywry with 'pip install pywry --upgrade'[/]"
+        )
+        if not hasattr(PyWry, "__version__"):
+            try:
+                # pylint: disable=C0415
+                from pywry import __version__ as pywry_version
+            except ImportError:
+                self.max_retries = 0
+                return warnings.warn(message)
+
+            PyWry.__version__ = pywry_version  # pylint: disable=W0201
+
+        if version.parse(PyWry.__version__) < version.parse("0.5.12"):
+            self.max_retries = 0  # pylint: disable=W0201
+            return warnings.warn(message)
+
+        if version.parse(PyWry.__version__) > version.parse("0.5.12"):
+            return super().check_backend()
+
+        try:
+            return self.loop.run_until_complete(super().check_backend())
+        except Exception:
+            return None
+
+    def close(self, reset: bool = False):
+        """Close the backend."""
+        if reset:
+            self.max_retries = 50  # pylint: disable=W0201
+
+        super().close()
+
+
+async def download_plotly_js():
+    """Download or updates plotly.js to the assets folder."""
+    # pylint: disable=import-outside-toplevel
+    import aiohttp  # noqa
+    import warnings  # noqa
+
+    js_filename = PLOTLYJS_PATH.name
+    try:
+        # we use aiohttp to download plotly.js
+        # this is so we don't have to block the main thread
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(verify_ssl=False), trust_env=True
+        ) as session, session.get(f"https://cdn.plot.ly/{js_filename}") as resp:
+            with open(str(PLOTLYJS_PATH), "wb") as f:
+                while True:
+                    chunk = await resp.content.read(1024)
+                    if not chunk:
+                        break
+                    f.write(chunk)
+
+        # We delete the old version of plotly.js
+        for file in (PLOTS_CORE_PATH / "assets").glob("plotly*.js"):
+            if file.name != js_filename:
+                file.unlink(missing_ok=True)
+
+    except Exception as err:  # pylint: disable=W0703
+        warnings.warn(f"Error downloading plotly.js: {err}")
+
+
+def create_backend(charting_settings: Optional["ChartingSettings"] = None):
+    """Create the backend."""
+    # pylint: disable=import-outside-toplevel
+    import importlib
+
+    charting_module = importlib.import_module(
+        "openbb_core.app.model.charts.charting_settings", "charting_settings"
+    )
+
+    ChartingSettings = charting_module.ChartingSettings
+    charting_settings = charting_settings or ChartingSettings()
+    global BACKEND  # pylint: disable=W0603 # noqa
+    if BACKEND is None:
+        BACKEND = Backend(charting_settings)
+
+
+def get_backend():
+    """Get the backend instance."""
+    if BACKEND is None:
+        create_backend()
+    return BACKEND

openbb_platform/obbject_extensions/charting/openbb_charting/core/chart_style.py

@@ -0,0 +1,229 @@
+"""Chart and style helpers for Plotly."""
+
+# pylint: disable=C0302,R0902,W3301
+import json
+import sys
+from pathlib import Path
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Union,
+)
+from warnings import warn
+
+import plotly.graph_objects as go
+import plotly.io as pio
+
+from openbb_charting.core.config.openbb_styles import (
+    PLT_COLORWAY,
+    PLT_DECREASING_COLORWAY,
+    PLT_INCREASING_COLORWAY,
+)
+
+
+class ChartStyle:
+    """The class that helps with handling of style configurations.
+
+    It serves styles for 2 libraries. For `Plotly` this class serves absolute paths
+    to the .pltstyle files. For `Plotly` and `Rich` this class serves custom
+    styles as python dictionaries.
+    """
+
+    STYLES_REPO = Path(__file__).parent.parent / "styles"
+    user_styles_directory: Path = STYLES_REPO
+
+    plt_styles_available: Dict[str, Path] = {}
+    plt_style: str = "dark"
+    plotly_template: Dict[str, Any] = {}
+    mapbox_style: str = "dark"
+
+    line_color: str = ""
+    up_color: str = ""
+    down_color: str = ""
+    up_colorway: List[str] = []
+    down_colorway: List[str] = []
+    up_color_transparent: str = ""
+    down_color_transparent: str = ""
+
+    line_width: float = 1.5
+
+    initialized: bool = False
+
+    def __new__(cls, *args, **kwargs):  # pylint: disable=W0613
+        """Create a singleton."""
+        if not hasattr(cls, "instance"):
+            cls.instance = super().__new__(cls)  # pylint: disable=E1120
+        return cls.instance
+
+    def __init__(
+        self,
+        plt_style: Optional[str] = "",
+        user_styles_directory: Optional[Path] = None,
+    ):
+        """Initialize the class.
+
+        Parameters
+        ----------
+        plt_style : `str`, optional
+            The name of the Plotly style to use, by default ""
+        console_style : `str`, optional
+            The name of the Rich style to use, by default ""
+        """
+        if self.initialized:
+            return
+
+        self.initialized = True
+        self.user_styles_directory = user_styles_directory or self.user_styles_directory
+        self.plt_style = plt_style or self.plt_style
+        self.load_available_styles()
+        self.load_style(plt_style)
+        self.apply_style()
+
+    def apply_style(self, style: Optional[str] = "") -> None:
+        """Apply the style to the libraries."""
+        style = style or self.plt_style
+
+        if style != self.plt_style:
+            self.load_style(style)
+
+        style = style.lower().replace("light", "white")  # type: ignore
+
+        if self.plt_style and self.plotly_template:
+            self.plotly_template.setdefault("layout", {}).setdefault(
+                "mapbox", {}
+            ).setdefault("style", "dark")
+            if "tables" in self.plt_styles_available:
+                tables = self.load_json_style(self.plt_styles_available["tables"])
+                pio.templates["openbb_tables"] = go.layout.Template(tables)
+            try:
+                pio.templates["openbb"] = go.layout.Template(self.plotly_template)
+            except ValueError as err:
+                if "plotly.graph_objs.Layout: 'legend2'" in str(err):
+                    warn(
+                        "[red]Warning: Plotly multiple legends are "
+                        "not supported in currently installed version.[/]\n\n"
+                        "[yellow]Please update plotly to version >= 5.15.0[/]\n"
+                        "[green]pip install plotly --upgrade[/]"
+                    )
+                    sys.exit(1)
+
+            if style in ["dark", "white"]:
+                pio.templates.default = f"plotly_{style}+openbb"
+                return
+
+            pio.templates.default = "openbb"
+            self.mapbox_style = (
+                self.plotly_template.setdefault("layout", {})
+                .setdefault("mapbox", {})
+                .setdefault("style", "dark")
+            )
+
+    def load_available_styles_from_folder(self, folder: Union[Path, str]) -> None:
+        """Load custom styles from folder.
+
+        Parses the styles/default and styles/user folders and loads style files.
+        To be recognized files need to follow a naming convention:
+        *.pltstyle        - plotly stylesheets
+        *.richstyle.json  - rich stylesheets
+
+        Parameters
+        ----------
+        folder : str
+            Path to the folder containing the stylesheets
+        """
+
+        if not isinstance(folder, Path) or not folder.exists():
+            return
+
+        for attr, ext in zip(
+            ["plt_styles_available", "console_styles_available"],
+            [".pltstyle.json", ".richstyle.json"],
+        ):
+            for file in folder.rglob(f"*{ext}"):
+                getattr(self, attr)[file.name.replace(ext, "")] = file
+
+    def load_available_styles(self) -> None:
+        """Load custom styles from default and user folders."""
+        self.load_available_styles_from_folder(self.STYLES_REPO)
+        self.load_available_styles_from_folder(self.user_styles_directory)
+
+    def load_json_style(self, file: Path) -> Dict[str, Any]:
+        """Load style from json file.
+
+        Parameters
+        ----------
+        file : Path
+            Path to the file containing the style
+
+        Returns
+        -------
+        Dict[str, Any]
+            Style as a dictionary
+        """
+        with open(file) as f:
+            return json.load(f)
+
+    def load_style(self, style: Optional[str] = "") -> None:
+        """Load style from file.
+
+        Parameters
+        ----------
+        style : str
+            Name of the style to load
+        """
+        style = style or self.plt_style
+
+        if style not in self.plt_styles_available:
+            warn(
+                f"[red]Plot Style {style} not found. Using default style.[/red]",
+            )
+            style = "dark"
+
+        self.load_plt_style(style)
+
+    def load_plt_style(self, style: str) -> None:
+        """Load Plotly style from file.
+
+        Parameters
+        ----------
+        style : str
+            Name of the style to load
+        """
+        self.plt_style = style
+        self.plotly_template = self.load_json_style(self.plt_styles_available[style])
+        line = self.plotly_template.pop("line", {})
+
+        self.up_color = line.get("up_color", "#00ACFF")
+        self.down_color = line.get("down_color", "#FF0000")
+        self.up_color_transparent = line.get(
+            "up_color_transparent", "rgba(0, 170, 255, 0.50)"
+        )
+        self.down_color_transparent = line.get(
+            "down_color_transparent", "rgba(230, 0, 57, 0.50)"
+        )
+        self.line_color = line.get("color", "#ffed00")
+        self.line_width = line.get("width", self.line_width)
+        self.down_colorway = line.get("down_colorway", PLT_DECREASING_COLORWAY)
+        self.up_colorway = line.get("up_colorway", PLT_INCREASING_COLORWAY)
+
+    def get_colors(self, reverse: bool = False) -> list:
+        """Get colors for the plot.
+
+        Parameters
+        ----------
+        reverse : bool, optional
+            Whether to reverse the colors, by default False
+
+        Returns
+        -------
+        list
+            List of colors e.g. ["#00ACFF", "#FF0000"]
+        """
+        colors = (
+            self.plotly_template.get("layout", {}).get("colorway", PLT_COLORWAY).copy()
+        )
+        if reverse:
+            colors.reverse()
+        return colors

openbb_platform/obbject_extensions/charting/openbb_charting/core/config/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Charting core configuration."""

openbb_platform/obbject_extensions/charting/openbb_charting/core/config/openbb_styles.py

@@ -0,0 +1,308 @@
+"""OpenBB Charting Styles."""
+
+from typing import TYPE_CHECKING, Any, List, Optional
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+# Vsurf Plot Settings
+PLT_3DMESH_COLORSCALE = "Jet"
+PLT_3DMESH_SCENE = dict(
+    xaxis=dict(
+        backgroundcolor="rgb(94, 94, 94)",
+        gridcolor="white",
+        showbackground=True,
+        zerolinecolor="white",
+    ),
+    yaxis=dict(
+        backgroundcolor="rgb(94, 94, 94)",
+        gridcolor="white",
+        showbackground=True,
+        zerolinecolor="white",
+    ),
+    zaxis=dict(
+        backgroundcolor="rgb(94, 94, 94)",
+        gridcolor="white",
+        showbackground=True,
+        zerolinecolor="white",
+    ),
+    aspectratio=dict(x=1.2, y=1.2, z=0.8),
+)
+PLT_3DMESH_HOVERLABEL = dict(bgcolor="gold")
+
+# Chart Plots Settings
+PLT_STYLE_TEMPLATE = "plotly_dark"
+PLT_STYLE_INCREASING = "#00ACFF"
+PLT_STYLE_DECREASING = "#e4003a"
+PLT_CANDLESTICKS = dict(
+    increasing=dict(line_color=PLT_STYLE_INCREASING, fillcolor=PLT_STYLE_INCREASING),
+    decreasing=dict(line_color=PLT_STYLE_DECREASING, fillcolor=PLT_STYLE_DECREASING),
+)
+PLT_STYLE_INCREASING_GREEN = "#00ACFF"
+PLT_STYLE_DECREASING_RED = "#e4003a"
+PLT_FONT = dict(family="Arial", size=16)
+PLOTLY_FONT = dict(family="Arial", size=16)
+
+PLT_COLORWAY = [
+    "#ffed00",
+    "#ef7d00",
+    "#e4003a",
+    "#c13246",
+    "#822661",
+    "#48277c",
+    "#005ca9",
+    "#00aaff",
+    "#9b30d9",
+    "#af005f",
+    "#5f00af",
+    "#af87ff",
+]
+
+PLT_FIB_COLORWAY: List[Any] = [
+    "rgb(195, 50, 69)",  # 0
+    "rgb(130, 38, 96)",  # 0.235
+    "rgb(120, 70, 200)",  # 0.382
+    "rgb(0, 93, 168)",  # 0.5
+    "rgb(173, 0, 95)",  # 0.618
+    "rgb(235, 184, 0)",  # 0.65 Golden Pocket
+    "rgb(162, 115, 206)",  # 1
+    dict(family="Arial Black", size=10),  # Fib's Text
+    dict(color="rgb(0, 230, 195)", width=0.9, dash="dash"),  # Fib Trendline
+]
+
+PLT_INCREASING_COLORWAY = [
+    "rgba(0, 150, 255, 1)",
+    "rgba(0, 170, 255, 0.92)",
+    "rgba(0, 170, 255, 0.90)",
+    "rgba(0, 170, 255, 0.80)",
+    "rgba(0, 170, 255, 0.70)",
+    "rgba(0, 170, 255, 0.60)",
+    "rgba(0, 170, 255, 0.50)",
+    "rgba(0, 170, 255, 0.40)",
+    "rgba(0, 170, 255, 0.34)",
+    "rgba(0, 170, 255, 0.22)",
+    "rgba(0, 170, 255, 0.10)",
+    "rgba(0, 170, 255, 0.05)",
+]
+
+PLT_DECREASING_COLORWAY = [
+    "rgba(230, 0, 57, 1)",
+    "rgba(230, 0, 57, 0.92)",
+    "rgba(230, 0, 57, 0.90)",
+    "rgba(230, 0, 57, 0.80)",
+    "rgba(230, 0, 57, 0.70)",
+    "rgba(230, 0, 57, 0.60)",
+    "rgba(230, 0, 57, 0.50)",
+    "rgba(230, 0, 57, 0.40)",
+    "rgba(230, 0, 57, 0.34)",
+    "rgba(230, 0, 57, 0.22)",
+    "rgba(230, 0, 57, 0.10)",
+    "rgba(230, 0, 57, 0.05)",
+]
+
+PLT_INCREASING_COLORWAY_GREEN = [
+    "rgba(0, 150, 0, 1)",
+    "rgba(0, 150, 0, 0.92)",
+    "rgba(0, 150, 0, 0.90)",
+    "rgba(0, 150, 0, 0.80)",
+    "rgba(0, 150, 0, 0.70)",
+    "rgba(0, 150, 0, 0.60)",
+    "rgba(0, 150, 0, 0.50)",
+    "rgba(0, 150, 0, 0.40)",
+    "rgba(0, 150, 0, 0.34)",
+    "rgba(0, 150, 0, 0.22)",
+    "rgba(0, 150, 0, 0.10)",
+    "rgba(0, 150, 0, 0.05)",
+]
+
+PLT_DECREASING_COLORWAY_RED = [
+    "rgba(200, 0, 0, 1)",
+    "rgba(200, 0, 0, 0.92)",
+    "rgba(200, 0, 0, 0.90)",
+    "rgba(200, 0, 0, 0.80)",
+    "rgba(200, 0, 0, 0.70)",
+    "rgba(200, 0, 0, 0.60)",
+    "rgba(200, 0, 0, 0.50)",
+    "rgba(200, 0, 0, 0.40)",
+    "rgba(200, 0, 0, 0.34)",
+    "rgba(200, 0, 0, 0.22)",
+    "rgba(200, 0, 0, 0.10)",
+    "rgba(200, 0, 0, 0.05)",
+]
+
+
+# Table Plots Settings
+PLT_TBL_HEADER = dict(
+    fill_color="rgb(30, 30, 30)",
+    font_color="white",
+    line_color="#6e6e6e",
+    line_width=1,
+)
+PLT_TBL_CELLS = dict(
+    font_color="white",
+    line_color="#6e6e6e",
+    line_width=0,
+)
+PLT_TBL_ROW_COLORS = (
+    "#333333",
+    "#242424",
+)
+
+
+def de_increasing_color_list(
+    df_column: Optional["DataFrame"] = None,
+    text: Optional[str] = None,
+    contains_str: str = "-",
+    increasing_color: str = PLT_STYLE_INCREASING,
+    decreasing_color: str = PLT_STYLE_DECREASING,
+) -> List[str]:
+    """Make a colorlist for decrease/increase if value in df_column.
+
+    Contains "{contains_str}" default is "-"
+
+    Parameters
+    ----------
+    df_column : DataFrame, optional
+        Dataframe column to create colorlist. by default None
+    text : str, optional
+        Search in a string, by default None
+    contains_str : str, optional
+        Decreasing String to search for in df_column. The default is "-".
+    increasing_color : str, optional
+        Color to use for increasing values. The default is PLT_STYLE_INCREASING.
+    decreasing_color : str, optional
+        Color to use for decreasing values. The default is PLT_STYLE_DECREASING.
+
+    Returns
+    -------
+    List[str]
+        List of colors for df_column
+    """
+    if df_column is None:
+        colorlist = [decreasing_color if contains_str in text else increasing_color]  # type: ignore
+    else:
+        colorlist = [
+            decreasing_color if boolv else increasing_color
+            for boolv in df_column.astype(str).str.contains(contains_str)
+        ]
+    return colorlist
+
+
+PLOTLY_THEME = dict(
+    # Layout
+    layout=dict(
+        colorway=PLT_COLORWAY,
+        font=PLOTLY_FONT,
+        yaxis=dict(
+            side="right",
+            zeroline=True,
+            fixedrange=False,
+            title_standoff=20,
+            nticks=15,
+            showline=True,
+            showgrid=True,
+            ticklen=0,
+        ),
+        yaxis2=dict(
+            side="left",
+            zeroline=False,
+            fixedrange=False,
+            anchor="x",
+            layer="above traces",
+            overlaying="y2",
+            nticks=6,
+            tick0=0.5,
+            title_standoff=10,
+            tickfont=dict(size=12),
+            showline=False,
+            ticklen=0,
+        ),
+        yaxis3=dict(
+            zeroline=False,
+            fixedrange=False,
+            anchor="x",
+            layer="above traces",
+            overlaying="y3",
+            nticks=6,
+            tick0=0.5,
+            title_standoff=10,
+            tickfont=dict(size=12),
+            showline=True,
+            ticklen=0,
+        ),
+        yaxis4=dict(
+            zeroline=False,
+            fixedrange=False,
+            anchor="x",
+            layer="above traces",
+            overlaying="y4",
+            nticks=6,
+            tick0=0.5,
+            title_standoff=10,
+            tickfont=dict(size=12),
+            showline=True,
+            ticklen=0,
+        ),
+        xaxis=dict(
+            showgrid=True,
+            zeroline=False,
+            showline=True,
+            rangeslider=dict(visible=False),
+            tickfont=dict(size=16),
+            title_standoff=20,
+            ticklen=0,
+        ),
+        xaxis2=dict(
+            showgrid=True,
+            zeroline=False,
+            showline=True,
+            rangeslider=dict(visible=False),
+            tickfont=dict(size=12),
+            title_standoff=20,
+            ticklen=0,
+        ),
+        xaxis3=dict(
+            showgrid=True,
+            zeroline=False,
+            showline=True,
+            rangeslider=dict(visible=False),
+            tickfont=dict(size=12),
+            title_standoff=20,
+            ticklen=0,
+        ),
+        xaxis4=dict(
+            showgrid=True,
+            zeroline=False,
+            showline=True,
+            rangeslider=dict(visible=False),
+            tickfont=dict(size=12),
+            title_standoff=20,
+            ticklen=0,
+        ),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=0.95,
+            font=dict(size=12),
+        ),
+        dragmode="pan",
+        hovermode="x",
+        hoverlabel=dict(align="left"),
+    ),
+    data=dict(
+        candlestick=[
+            dict(
+                increasing=dict(
+                    line=dict(color=PLT_STYLE_INCREASING),
+                    fillcolor=PLT_STYLE_INCREASING,
+                ),
+                decreasing=dict(
+                    line=dict(color=PLT_STYLE_DECREASING),
+                    fillcolor=PLT_STYLE_DECREASING,
+                ),
+            )
+        ]
+    ),
+)

openbb_platform/obbject_extensions/charting/openbb_charting/core/dummy_backend.py

@@ -0,0 +1,56 @@
+"""Dummy backend for charting to avoid import errors."""
+
+import asyncio
+from queue import Queue
+from typing import List
+
+import dotenv
+from openbb_core.app.constants import OPENBB_DIRECTORY
+
+SETTINGS_ENV_FILE = OPENBB_DIRECTORY / ".env"
+
+
+class DummyBackend:
+    """Dummy class to avoid import errors."""
+
+    __version__ = "0.0.0"
+
+    max_retries = 0
+    outgoing: List[str] = []
+    init_engine: List[str] = []
+    daemon = True
+    debug = False
+    shell = False
+    base = None
+    recv: Queue = Queue()
+
+    def __new__(cls, *args, **kwargs):  # pylint: disable=W0613
+        """Create a singleton instance of the backend."""
+        if not hasattr(cls, "instance"):
+            cls.instance = super().__new__(cls)  # pylint: disable=E1120
+        return cls.instance
+
+    def __init__(self, daemon: bool = True, max_retries: int = 30):
+        """Use cummy init to avoid import errors."""
+        self.daemon = daemon
+        self.max_retries = max_retries
+        try:
+            self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self.loop)
+
+        dotenv.set_key(SETTINGS_ENV_FILE, "PLOT_ENABLE_PYWRY", "0")
+
+    def close(self, reset: bool = False):  # pylint: disable=W0613
+        """Close the backend."""
+
+    def start(self, debug: bool = False):  # pylint: disable=W0613
+        """Start the backend."""
+
+    def send_outgoing(self, outgoing: dict):
+        """Send outgoing data to the backend."""
+
+    async def check_backend(self):
+        """Check backend method to avoid errors and revert to browser."""
+        raise Exception

openbb_platform/obbject_extensions/charting/openbb_charting/core/openbb_figure.py

@@ -0,0 +1,1662 @@
+"""OpenBB Figure Class."""
+
+# pylint: disable=C0302,R0902,W3301,R0917
+import json
+import textwrap
+from datetime import datetime, timedelta
+from math import floor
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+)
+from warnings import warn
+
+import plotly.graph_objects as go
+import plotly.io as pio
+from plotly.subplots import make_subplots
+
+from openbb_charting.core.backend import PLOTLYJS_PATH, create_backend, get_backend
+from openbb_charting.core.config.openbb_styles import (
+    PLT_TBL_ROW_COLORS,
+)
+
+if TYPE_CHECKING:
+    from numpy import ndarray
+    from openbb_core.app.model.charts.charting_settings import ChartingSettings
+    from pandas import DataFrame, Series
+
+    try:  # noqa: SIM105
+        # pylint: disable=W0611 # noqa: F401
+        from darts import TimeSeries
+    except ImportError:
+        pass
+
+TimeSeriesT = TypeVar("TimeSeriesT", bound="TimeSeries")
+
+pio.default_renderers = "notebook"
+
+
+class OpenBBFigure(go.Figure):
+    """Custom Figure class for OpenBB Terminal.
+
+    Parameters
+    ----------
+    fig : `go.Figure`, optional
+        Figure to copy, by default None
+    **kwargs
+        Keyword arguments to pass to `go.Figure.update_layout`
+
+    Attributes
+    ----------
+    has_subplots : `bool`
+        Whether the figure has subplots
+
+    Class Methods
+    -------------
+    create_subplots(rows: `int`, cols: `int`, **kwargs) -> `OpenBBFigure`
+        Creates a subplots figure
+    to_table(data: `DataFrame`, columnwidth: `list`, print_index: `bool`, ...)
+        Converts a DataFrame to a table figure
+
+    Methods
+    -------
+    add_hline_legend(y: `float`, name: `str`, line: `dict`, legendrank: `int`, **kwargs)
+        Adds a horizontal line with a legend label
+    add_vline_legend(x: `float`, name: `str`, line: `dict`, legendrank: `int`, **kwargs)
+        Adds a vertical line with a legend label
+    add_legend_label(trace: `str`, label: `str`, mode: `str`, marker: `dict`, **kwargs)
+        Adds a legend label
+    add_histplot(x: `list`, name: `str`, colors: `list`, bins: `int`, show_curve: `str`, ...)
+        Adds a histogram plot
+    horizontal_legend(x: `float`, y: `float`, xanchor: `str`, yanchor: `str`, ...)
+        Moves the legend to a horizontal position
+    to_subplot(subplot: `OpenBBFigure`, row: `int`, col: `int`, secondary_y: `bool`, ...)
+        Returns the figure as a subplot of another figure
+    """
+
+    plotlyjs_path: Path = PLOTLYJS_PATH
+
+    def __init__(self, fig: Optional[go.Figure] = None, **kwargs) -> None:
+        """Initialize the OpenBBFigure."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_charting.core.chart_style import ChartStyle
+
+        super().__init__()
+        if fig:
+            self.__dict__ = fig.__dict__
+
+        self._charting_settings: Optional[ChartingSettings] = kwargs.pop(
+            "charting_settings", None
+        )
+        self._has_secondary_y = kwargs.pop("has_secondary_y", False)
+        self._subplots_kwargs: Dict[str, Any] = kwargs.pop("subplots_kwargs", {})
+        self._multi_rows = kwargs.pop("multi_rows", False)
+        self._added_logscale = False
+        self._date_xaxs: dict = {}
+        self._margin_adjusted = False
+        self._feature_flags_applied = False
+        self._exported = False
+        self._cmd_xshift = 0
+        self._bar_width = 0.15
+        self._export_image: Optional[Union[Path, str]] = ""
+        self._subplot_xdates: Dict[int, Dict[int, List[Any]]] = {}
+
+        if kwargs.pop("create_backend", False):
+            create_backend(self._charting_settings)
+            get_backend().start(
+                debug=getattr(self._charting_settings, "debug_mode", False)
+            )
+        self._theme = ChartStyle(
+            getattr(self._charting_settings, "plt_style", ""),
+            getattr(self._charting_settings, "user_styles_directory", None),
+        )
+
+        if xaxis := kwargs.pop("xaxis", None):
+            self.update_xaxes(xaxis)
+        if yaxis := kwargs.pop("yaxis", None):
+            self.update_yaxes(yaxis)
+
+        self.update_layout(**kwargs)
+
+        self._backend = get_backend()
+
+        if self._backend.isatty:
+            self.update_layout(
+                margin=dict(l=0, r=0, t=0, b=0, pad=0, autoexpand=True),
+                height=self._backend.HEIGHT,
+                width=self._backend.WIDTH,
+            )
+
+    @property
+    def theme(self):
+        """Theme property."""
+        return self._theme
+
+    @property
+    def subplots_kwargs(self):
+        """Get subplots kwargs property."""
+        return self._subplots_kwargs
+
+    @subplots_kwargs.setter
+    def subplots_kwargs(self, value):
+        """Get subplots kwargs setter."""
+        self._subplots_kwargs = value
+
+    @property
+    def has_subplots(self):
+        """Has subplots property."""
+        return self._has_subplots()
+
+    @property
+    def bar_width(self):
+        """Bar width property."""
+        return self._bar_width
+
+    @bar_width.setter
+    def bar_width(self, value):
+        """Bar width setter."""
+        self._bar_width = value
+
+    @property
+    def cmd_xshift(self):
+        """Command line x shift property."""
+        return self._cmd_xshift
+
+    @cmd_xshift.setter
+    def cmd_xshift(self, value):
+        """Command line x shift setter."""
+        self._cmd_xshift = value
+
+    @classmethod
+    def create_subplots(  # pylint: disable=too-many-arguments
+        cls,
+        rows: int = 1,
+        cols: int = 1,
+        shared_xaxes: bool = True,
+        vertical_spacing: Optional[float] = None,
+        horizontal_spacing: Optional[float] = None,
+        subplot_titles: Optional[Union[List[str], tuple]] = None,
+        row_width: Optional[List[Union[float, int]]] = None,
+        specs: Optional[List[List[Optional[Dict[Any, Any]]]]] = None,
+        **kwargs,
+    ) -> "OpenBBFigure":
+        """Create a new Plotly figure with subplots.
+
+        Parameters
+        ----------
+        rows : `int`, optional
+            Number of rows, by default 1
+        cols : `int`, optional
+            Number of columns, by default 1
+        shared_xaxes : `bool`, optional
+            Whether to share x axes, by default True
+        vertical_spacing : `float`, optional
+            Vertical spacing between subplots, by default None
+        horizontal_spacing : `float`, optional
+            Horizontal spacing between subplots, by default None
+        subplot_titles : `Union[List[str], tuple]`, optional
+            Titles for each subplot, by default None
+        row_width : `List[Union[float, int]]`, optional
+            Width of each row, by default [1]
+        specs : `List[List[dict]]`, optional
+            Subplot specs, by default `[[{}] * cols] * rows` (all subplots are the same size)
+        """
+        # We save the original kwargs to store them in the figure for later use
+        subplots_kwargs = dict(
+            rows=rows,
+            cols=cols,
+            shared_xaxes=shared_xaxes,
+            vertical_spacing=vertical_spacing,
+            horizontal_spacing=horizontal_spacing,
+            subplot_titles=subplot_titles,
+            row_width=row_width or [1] * rows,
+            specs=specs or [[{}] * cols] * rows,
+            **kwargs,
+        )
+
+        fig = make_subplots(**subplots_kwargs)
+
+        kwargs = {
+            "multi_rows": rows > 1,
+            "subplots_kwargs": subplots_kwargs,
+        }
+        if specs and any(
+            spec.get("secondary_y", False) for row in specs for spec in row if spec
+        ):
+            kwargs["has_secondary_y"] = True
+
+        return cls(fig, **kwargs)
+
+    def add_trend(
+        self,
+        data: "DataFrame",
+        row: int = 1,
+        col: int = 1,
+        secondary_y: bool = False,
+        **kwargs,
+    ):
+        """Add a trend line to the figure.
+
+        Parameters
+        ----------
+        data : `DataFrame`
+            Data to plot
+        row : `int`, optional
+            Row number, by default 1
+        col : `int`, optional
+            Column number, by default 1
+        secondary_y : `bool`, optional
+            Whether to plot on secondary y axis, by default None
+        """
+        try:
+            for column, color in zip(
+                ["OC_High_trend", "OC_Low_trend"],
+                [self._theme.up_color, self._theme.down_color],
+            ):
+                if column in data.columns:
+                    name = column.split("_")[1].title()
+                    trend = data.copy().dropna()
+                    self.add_shape(
+                        type="line",
+                        name=f"{name} Trend",
+                        x0=trend.index[0],
+                        y0=trend[column].iloc[0],
+                        x1=trend.index[-1],
+                        y1=trend[column].iloc[-1],
+                        line=dict(color=color, width=2),
+                        row=row,
+                        col=col,
+                        secondary_y=secondary_y,
+                        **kwargs,
+                    )
+
+        except Exception as e:
+            raise ValueError(f"Error adding trend line: {e}") from e
+
+    def add_histplot(  # pylint: disable=too-many-arguments,too-many-locals
+        self,
+        dataset: Union["ndarray", "Series", TimeSeriesT],
+        name: Optional[Union[str, List[str]]] = None,
+        colors: Optional[List[str]] = None,
+        bins: Union[int, str] = 15,
+        curve: Literal["normal", "kde"] = "normal",
+        show_curve: bool = True,
+        show_rug: bool = True,
+        show_hist: bool = True,
+        forecast: bool = False,
+        row: int = 1,
+        col: int = 1,
+    ) -> None:
+        """Add a histogram with a curve and rug plot if desired.
+
+        Parameters
+        ----------
+        dataset : `Union[ndarray, Series, TimeSeriesT]`
+            Data to plot
+        name : `Optional[Union[str, List[str]]]`, optional
+            Name of the plot, by default None
+        colors : `Optional[List[str]]`, optional
+            Colors of the plot, by default None
+        bins : `Union[int, str]`, optional
+            Number of bins, by default 15
+        curve : `Literal["normal", "kde"]`, optional
+            Type of curve to plot, by default "normal"
+        show_curve : `bool`, optional
+            Whether to show the curve, by default True
+        show_rug : `bool`, optional
+            Whether to show the rug plot, by default True
+        show_hist : `bool`, optional
+            Whether to show the histogram, by default True
+        forecast : `bool`, optional
+            Whether the data is a darts forecast TimeSeries, by default False
+        row : `int`, optional
+            Row of the subplot, by default 1
+        col : `int`, optional
+            Column of the subplot, by default 1
+        """
+        # pylint: disable=import-outside-toplevel
+        from numpy import linspace, mean, ndarray, std
+        from pandas import Series
+        from scipy import stats
+
+        callback = stats.norm if curve == "normal" else stats.gaussian_kde
+
+        def _validate_x(data: Union[ndarray, Series, type[TimeSeriesT]]):
+            if forecast:
+                data = data.univariate_values()  # type: ignore
+            if isinstance(data, Series):
+                data = data.to_numpy()
+            if isinstance(data, ndarray):
+                data = data.tolist()
+            if isinstance(data, list):
+                data = [data]
+
+            return data
+
+        valid_x = _validate_x(dataset)
+
+        if isinstance(name, str):
+            name = [name]
+
+        if isinstance(colors, str):
+            colors = [colors]
+        if not name:
+            name = [None] * len(valid_x)  # type: ignore
+        if not colors:
+            colors = [None] * len(valid_x)  # type: ignore
+
+        max_y = 0
+        for i, (x_i, name_i, color_i) in enumerate(zip(valid_x, name, colors)):
+            if not color_i:
+                color_i = (  # noqa: PLW2901
+                    self._theme.up_color if i % 2 == 0 else self._theme.down_color
+                )
+
+            res_mean, res_std = mean(x_i), std(x_i)
+            res_min, res_max = min(x_i), max(x_i)
+            x = linspace(res_min, res_max, 100)
+            if show_hist:
+                if forecast:
+                    components = list(dataset.components[:4])  # type: ignore
+                    values = (
+                        dataset[components].all_values(copy=False).flatten(order="F")  # type: ignore
+                    )
+                    n_components = len(components)
+                    n_entries = len(values) // n_components
+                    for i2, label in zip(range(n_components), components):
+                        self.add_histogram(
+                            x=values[
+                                i2 * n_entries : (i2 + 1) * n_entries  # noqa: E203
+                            ],  # noqa: E203
+                            name=label,
+                            marker_color=color_i,
+                            nbinsx=bins,
+                            opacity=0.7,
+                            row=row,
+                            col=col,
+                        )
+                else:
+                    self.add_histogram(
+                        x=x_i,
+                        name=name_i,
+                        marker_color=color_i,
+                        nbinsx=bins,
+                        histnorm="probability density",
+                        histfunc="sum",
+                        opacity=0.7,
+                        row=row,
+                        col=col,
+                    )
+
+            if show_rug:
+                self.add_scatter(
+                    x=x_i,
+                    y=[0.00002] * len(x_i),
+                    name=name_i if len(name) < 2 else name[1],
+                    mode="markers",
+                    marker=dict(
+                        color=self._theme.down_color,
+                        symbol="line-ns-open",
+                        size=10,
+                    ),
+                    row=row,
+                    col=col,
+                )
+            if show_curve:
+                # type: ignore
+                if curve == "kde":
+                    curve_x = [None] * len(valid_x)
+                    curve_y = [None] * len(valid_x)
+                    # pylint: disable=consider-using-enumerate
+                    for index in range(len(valid_x)):
+                        curve_x[index] = [  # type: ignore
+                            res_min + xx * (res_max - res_min) / 500
+                            for xx in range(500)
+                        ]
+                        curve_y[index] = stats.gaussian_kde(valid_x[index])(
+                            curve_x[index]
+                        )
+                    for index in range(len(valid_x)):
+                        self.add_scatter(
+                            x=curve_x[index],  # type: ignore
+                            y=curve_y[index],  # type: ignore
+                            name=name_i,
+                            mode="lines",
+                            showlegend=False,
+                            marker=dict(color=color_i),
+                            row=row,
+                            col=col,
+                        )
+                        max_y = max(max_y, max(curve_y[index]) * 1.2)  # type: ignore
+
+                else:
+                    y = (
+                        callback(res_mean, res_std).pdf(x)
+                        * len(valid_x[0])
+                        * (res_max - res_min)
+                        / bins
+                    )
+
+                    self.add_scatter(
+                        x=x,
+                        y=y,
+                        name=name_i,
+                        mode="lines",
+                        marker=dict(color=color_i),
+                        showlegend=False,
+                        row=row,
+                        col=col,
+                    )
+
+                    max_y = max(max_y, y * 2)
+
+        self.update_yaxes(
+            position=0.0,
+            range=[0, max_y],
+            row=row,
+            col=col,
+            automargin=False,
+            autorange=False,
+        )
+
+        self.update_layout(barmode="overlay", bargap=0.01, bargroupgap=0)
+
+    def set_title(
+        self, title: str, wrap: bool = False, wrap_width: int = 80, **kwargs
+    ) -> "OpenBBFigure":
+        """Set the main title of the figure.
+
+        Parameters
+        ----------
+        title : `str`
+            Title of the figure
+        wrap : `bool`
+            If True, the title will be wrapped according to the wrap_width parameter
+        wrap_width : `int`
+            Width in characters to wrap the title if wrap is True, default is 80
+        """
+        if wrap:
+            title = "<br>".join(textwrap.wrap(title, width=wrap_width))
+
+        if kwargs.get("row") is not None and kwargs.get("col") is not None:
+            self.add_annotation(
+                text=title,
+                xref="x domain",
+                yref="y domain",
+                x=0.5,
+                y=1.0,
+                xanchor="center",
+                yanchor="bottom",
+                **kwargs,
+            )
+            return self
+
+        self.update_layout(title=dict(text=title, **kwargs))
+        return self
+
+    def set_xaxis_title(
+        self,
+        title: str,
+        row: Optional[int] = None,
+        col: Optional[int] = None,
+        **kwargs,
+    ) -> "OpenBBFigure":
+        """Set the x axis title of the figure or subplot (if row and col are specified).
+
+        Parameters
+        ----------
+        title : `str`
+            Title of the x axis
+        row : `int`, optional
+            Row number, by default None
+        col : `int`, optional
+            Column number, by default None
+        """
+        self.update_xaxes(title=title, row=row, col=col, **kwargs)
+        return self
+
+    def set_yaxis_title(
+        self, title: str, row: Optional[int] = None, col: Optional[int] = None, **kwargs
+    ) -> "OpenBBFigure":
+        """Set the y axis title of the figure or subplot (if row and col are specified).
+
+        Parameters
+        ----------
+        title : `str`
+            Title of the x axis
+        row : `int`, optional
+            Row number, by default None
+        col : `int`, optional
+            Column number, by default None
+        """
+        self.update_yaxes(title=title, row=row, col=col, **kwargs)
+        return self
+
+    def add_hline_legend(
+        self,
+        y: float,
+        name: str,
+        line: Optional[dict] = None,
+        legendrank: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        """Add a horizontal line with a legend label.
+
+        Parameters
+        ----------
+        y : `float`
+            y value of the line
+        name : `str`
+            Name of the to display in the legend
+        line : `dict`
+            Line style
+        legendrank : `int`, optional
+            Legend rank, by default None (e.g. 1 is above 2)
+        """
+        if line is None:
+            line = {}
+
+        self.add_hline(
+            y,
+            line=line,
+        )
+        self.add_legend_label(
+            label=name,
+            mode="lines",
+            line_dash=line.get("dash", "solid"),
+            marker=dict(color=line.get("color", self._theme.line_color)),
+            legendrank=legendrank,
+            **kwargs,
+        )
+
+    def add_vline_legend(
+        self,
+        x: float,
+        name: str,
+        line: Optional[dict] = None,
+        legendrank: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        """Add a vertical line with a legend label.
+
+        Parameters
+        ----------
+        x : `float`
+            x value of the line
+        name : `str`
+            Name of the to display in the legend
+        line : `dict`
+            Line style
+        legendrank : `int`, optional
+            Legend rank, by default None (e.g. 1 is above 2)
+        """
+        if line is None:
+            line = {}
+
+        self.add_vline(
+            x,
+            line=line,
+        )
+        self.add_legend_label(
+            label=name,
+            mode="lines",
+            line_dash=line.get("dash", "solid"),
+            marker=dict(color=line.get("color", self._theme.line_color)),
+            legendrank=legendrank,
+            **kwargs,
+        )
+
+    def horizontal_legend(  # noqa: PLR0913
+        self,
+        x: float = 1,
+        y: float = 1.02,
+        xanchor: str = "right",
+        yanchor: str = "bottom",
+        orientation: str = "h",
+        **kwargs,
+    ) -> None:
+        """Set the legend to be horizontal.
+
+        Parameters
+        ----------
+        x : `float`, optional
+            The x position of the legend, by default 1
+        y : `float`, optional
+            The y position of the legend, by default 1.02
+        xanchor : `str`, optional
+            The x anchor of the legend, by default "right"
+        yanchor : `str`, optional
+            The y anchor of the legend, by default "bottom"
+        orientation : `str`, optional
+            The orientation of the legend, by default "h"
+        """
+        self.update_layout(
+            legend=dict(
+                x=x,
+                y=y,
+                xanchor=xanchor,
+                yanchor=yanchor,
+                orientation=orientation,
+                **kwargs,
+            )
+        )
+
+    @staticmethod
+    def chart_volume_scaling(
+        df_volume: "DataFrame", volume_ticks_x: int = 7
+    ) -> Dict[str, list]:
+        """Take df_volume and returns volume_ticks, tickvals for chart volume scaling.
+
+        Parameters
+        ----------
+        df_volume : DataFrame
+            Dataframe of volume (e.g. df_volume = df["volume"])
+        volume_ticks_x : int, optional
+            Number to multiply volume, by default 7
+
+        Returns
+        -------
+        Dict[str, list]
+            {"range": volume_range, "ticks": tickvals}
+        """
+        # pylint: disable=import-outside-toplevel
+        from pandas import Series, to_numeric
+
+        df_volume = df_volume.apply(lambda x: f"{x:.1f}")
+        df_volume = to_numeric(df_volume.astype(float))
+
+        if isinstance(df_volume, Series):
+            df_volume = df_volume.to_frame()
+
+        volume_ticks = int(df_volume.max().max())
+        round_digits = -3
+        first_val = round(volume_ticks * 0.20, round_digits)
+
+        for x, y in zip([2, 5, 6, 7, 8, 9, 10], [1, 4, 5, 6, 7, 8, 9]):
+            if len(str(volume_ticks)) > x:
+                round_digits = -y
+                first_val = round(volume_ticks * 0.20, round_digits)
+
+        tickvals = [
+            floor(first_val),
+            floor(first_val * 2),
+            floor(first_val * 3),
+            floor(first_val * 4),
+        ]
+        volume_range = [0, floor(volume_ticks * volume_ticks_x)]
+
+        return {"range": volume_range, "ticks": tickvals}
+
+    def add_inchart_volume(  # noqa: PLR0913
+        self,
+        df_stock: "DataFrame",
+        close_col: Optional[str] = "close",
+        volume_col: Optional[str] = "volume",
+        row: Optional[int] = 1,
+        col: Optional[int] = 1,
+        volume_ticks_x: int = 7,
+    ) -> None:
+        """Add in-chart volume to a subplot.
+
+        Parameters
+        ----------
+        df_stock : `DataFrame`
+            Dataframe of the stock
+        close_col : `str`, optional
+            Name of the close column, by default "close"
+        volume_col : `str`, optional
+            Name of the volume column, by default "volume"
+        row : `int`, optional
+            Row number, by default 2
+        col : `int`, optional
+            Column number, by default 1
+        volume_ticks_x : int, optional
+            Number to multiply volume, by default 7
+        """
+        # pylint: disable=import-outside-toplevel
+        from numpy import where
+
+        colors = where(
+            df_stock.open < df_stock[close_col],
+            self._theme.up_color,
+            self._theme.down_color,
+        )
+        vol_scale = self.chart_volume_scaling(df_stock[volume_col], volume_ticks_x)
+        self.add_bar(
+            x=df_stock.index,
+            y=df_stock[volume_col],
+            name="Volume",
+            marker_color=colors,
+            yaxis="y2",
+            row=row,
+            col=col,
+            opacity=0.5,
+            secondary_y=True,
+            showlegend=False,
+            hovertemplate="%{y}<extra></extra>",
+        )
+        ticksize = 13 - (self.subplots_kwargs["rows"] // 2)
+        self.update_layout(
+            yaxis2=dict(
+                fixedrange=False,
+                side="left",
+                nticks=8,
+                autorange=False,
+                range=vol_scale["range"],
+                tickvals=vol_scale["ticks"],
+                showgrid=False,
+                showline=False,
+                zeroline=False,
+                tickfont=dict(size=ticksize),
+                overlaying="y",
+            ),
+            yaxis=dict(
+                autorange=True,
+                automargin=True,
+                side="right",
+                fixedrange=False,
+                anchor="x",
+                layer="above traces",
+            ),
+        )
+
+    def add_legend_label(  # noqa: PLR0913
+        self,
+        trace: Optional[str] = None,
+        label: Optional[str] = None,
+        mode: Optional[str] = None,
+        marker: Optional[dict] = None,
+        line_dash: Optional[str] = None,
+        legendrank: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        """Add a legend label.
+
+        Parameters
+        ----------
+        trace : `str`, optional
+            The name of the trace to use as a template, by default None
+        label : `str`, optional
+            The label to use, by default None (uses the trace name if trace is specified)
+            If trace is not specified, label must be specified
+        mode : `str`, optional
+            The mode to use, by default "lines" (uses the trace mode if trace is specified)
+        marker : `dict`, optional
+            The marker to use, by default dict() (uses the trace marker if trace is specified)
+        line_dash : `str`, optional
+            The line dash to use, by default "solid" (uses the trace line dash if trace is specified)
+        legendrank : `int`, optional
+            The legend rank, by default None (e.g. 1 is above 2)
+
+        Raises
+        ------
+        ValueError
+            If trace is not found
+        ValueError
+            If label is not specified and trace is not specified
+        """
+        if trace:
+            for trace_ in self.data:
+                if trace_.name == trace:
+                    for arg, default in zip(
+                        [label, mode, marker, line_dash],
+                        [trace, trace_.mode, trace_.marker, trace_.line_dash],
+                    ):
+                        if not arg and default:
+                            arg = default  # noqa: PLW2901
+
+                    kwargs.update(dict(yaxis=trace_.yaxis))
+                    break
+            else:
+                raise ValueError(f"Trace '{trace}' not found")
+
+        if not label:
+            raise ValueError("Label must be specified")
+
+        self.add_scatter(
+            x=[None],
+            y=[None],
+            mode=mode or "lines",
+            name=label,
+            marker=marker or dict(),
+            line_dash=line_dash or "solid",
+            legendrank=legendrank,
+            **kwargs,
+        )
+
+    def show(  # noqa: PLR0915
+        self,
+        *args,
+        external: bool = False,
+        export_image: Optional[Union[Path, str]] = "",
+        **kwargs,
+    ) -> "OpenBBFigure":
+        """Show the figure.
+
+        Parameters
+        ----------
+        external : `bool`, optional
+            Whether to return the figure object instead of showing it, by default False
+        export_image : `Union[Path, str]`, optional
+            The path to export the figure image to, by default ""
+        cmd_xshift : `int`, optional
+            The x shift of the command source annotation, by default 0
+        bar_width : `float`, optional
+            The width of the bars, by default 0.0001
+        date_xaxis : `bool`, optional
+            Whether to check if the xaxis is a date axis, by default True
+        """
+        self.cmd_xshift = kwargs.pop("cmd_xshift", self.cmd_xshift)
+        self.bar_width = kwargs.pop("bar_width", self.bar_width)
+        self._export_image = export_image
+
+        if export_image and not self._backend.isatty:
+            if isinstance(export_image, str):
+                export_image = Path(export_image).resolve()
+            export_image.touch()
+
+        if kwargs.pop("margin", True):
+            self._adjust_margins()
+
+        self._apply_feature_flags()
+        if kwargs.pop("date_xaxis", True):
+            self.add_rangebreaks()
+            self._xaxis_tickformatstops()
+
+        self.update_traces(marker_line_width=self.bar_width, selector=dict(type="bar"))
+        self.update_traces(
+            selector=dict(type="scatter", hovertemplate=None),
+            hovertemplate="%{y}",
+        )
+
+        # Set modebar style
+        if self._backend.isatty:
+            self.update_layout(  # type: ignore
+                newshape_line_color=(
+                    "gold" if self._theme.mapbox_style == "dark" else "#0d0887"
+                ),
+                modebar=dict(
+                    orientation="v",
+                    bgcolor="#2A2A2A" if self._theme.mapbox_style == "dark" else "gray",
+                    color="#FFFFFF" if self._theme.mapbox_style == "dark" else "black",
+                    activecolor=(
+                        "#d1030d" if self._theme.mapbox_style == "dark" else "blue"
+                    ),
+                ),
+                spikedistance=2,
+                hoverdistance=2,
+            )
+
+        if external or self._exported:
+            return self  # type: ignore
+
+        if getattr(self._charting_settings, "headless", False):
+            return self.to_json()
+
+        kwargs.update(config=dict(scrollZoom=True, displaylogo=False))
+        if self._backend.isatty:
+            try:
+                # We check if we need to export the image
+                # This is done to avoid opening after exporting
+                if export_image:
+                    self._exported = True
+
+                # We send the figure to the backend to be displayed
+                return self._backend.send_figure(fig=self, export_image=export_image)
+            except Exception as e:
+                # If the backend fails, we just show the figure normally
+                # This is a very rare case, but it's better to have a fallback
+
+                warn(f"Failed to show figure with backend. {e}")
+
+                # We check if any figures were initialized before the backend failed
+                # If so, we show them with the default plotly backend
+                queue = self._backend.get_pending()
+                for pending in queue:
+                    data = json.loads(pending).get("json_data", {})
+                    if data.get("layout", {}):
+                        pio.show(data, *args, **kwargs)
+
+        return pio.show(self, *args, **kwargs)
+
+    def _xaxis_tickformatstops(self) -> None:
+        """Set the datetickformatstops for the xaxis if the x data is datetime."""
+        if (dateindex := self.get_dateindex()) is None or list(
+            self.select_xaxes(lambda x: hasattr(x, "tickformat") and x.tickformat)
+        ):
+            return
+
+        tickformatstops = [
+            dict(dtickrange=[None, 86_400_000], value="%I:%M%p\n%b,%d"),
+            dict(dtickrange=[86_400_000, 604_800_000], value="%Y-%m-%d"),
+        ]
+        xhoverformat = "%I:%M%p %Y-%m-%d"
+
+        # We check if daily data if the first and second time are the same
+        # since daily data will have the same time (2021-01-01 00:00:00)
+        if (
+            not hasattr(dateindex[-1], "time")
+            or dateindex[-1].time() == dateindex[-2].time()
+        ):
+            xhoverformat = "%Y-%m-%d"
+            tickformatstops = [dict(dtickrange=[None, 604_800_000], value="%Y-%m-%d")]
+
+        for entry in self._date_xaxs.values():
+            self.update_xaxes(
+                tickformatstops=[
+                    *tickformatstops,
+                    dict(dtickrange=[604_800_000, "M1"], value="%Y-%m-%d"),
+                    dict(dtickrange=["M1", None], value="%Y-%m-%d"),
+                ],
+                type="date",
+                row=entry["row"],
+                col=entry["col"],
+                tick0=0.5,
+            )
+            self.update_traces(
+                xhoverformat=xhoverformat, selector=dict(name=entry["name"])
+            )
+
+    def get_subplots_dict(self) -> Dict[str, Dict[str, List[Any]]]:
+        """Return the subplots dict.
+
+        Returns
+        -------
+        `dict`
+            The subplots dict
+        """
+        subplots: Dict[str, Dict[str, List[Any]]] = {}
+
+        if not self.has_subplots:
+            return subplots
+
+        grid_ref = self._validate_get_grid_ref()  # pylint: disable=protected-access
+        for r, plot_row in enumerate(grid_ref):
+            for c, plot_refs in enumerate(plot_row):
+                if not plot_refs:
+                    continue
+                for subplot_ref in plot_refs:
+                    if subplot_ref.subplot_type == "xy":
+                        xaxis, yaxis = subplot_ref.layout_keys
+                        xref = xaxis.replace("axis", "")
+                        yref = yaxis.replace("axis", "")
+                        row = r + 1
+                        col = c + 1
+                        subplots.setdefault(xref, {}).setdefault(yref, []).append(
+                            (row, col)
+                        )
+
+        return subplots
+
+    def get_dateindex(self) -> Optional[List[datetime]]:
+        """Return the dateindex of the figure.
+
+        Returns
+        -------
+        `list`
+            The dateindex
+        """
+        # pylint: disable=import-outside-toplevel
+        from numpy import datetime64
+        from pandas import DatetimeIndex, to_datetime
+
+        output: Optional[List[datetime]] = None
+        subplots = self.get_subplots_dict()
+
+        try:
+            false_y = list(self.select_traces(secondary_y=False))
+            true_y = list(self.select_traces(secondary_y=True))
+        except Exception:
+            false_y = []
+            true_y = []
+
+        for trace in self.select_traces():
+            if not hasattr(trace, "xaxis"):
+                continue
+            xref, yref = trace.xaxis, trace.yaxis
+            row, col = subplots.get(xref, {}).get(yref, [(None, None)])[0]
+
+            if trace.x is not None and len(trace.x) > 5:
+                for x in trace.x[:2]:
+                    if isinstance(x, (datetime, datetime64, DatetimeIndex)):
+                        output = trace.x
+                        name = trace.name if hasattr(trace, "name") else f"{trace}"
+
+                        secondary_y: Optional[bool] = trace in true_y
+                        if trace not in (false_y + true_y):
+                            secondary_y = None
+
+                        self._date_xaxs[trace.xaxis] = {
+                            "yaxis": trace.yaxis,
+                            "name": name,
+                            "row": row,
+                            "col": col,
+                            "secondary_y": secondary_y,
+                        }
+                        self._subplot_xdates.setdefault(row, {}).setdefault(
+                            col, []
+                        ).append(trace.x)
+
+        # We convert the dateindex to a list of datetime objects if it's a numpy array
+        if output is not None and isinstance(output[0], datetime64):
+            output = (
+                to_datetime(output).to_pydatetime().astype("datetime64[ms]").tolist()
+            )
+
+        return output
+
+    def hide_date_gaps(
+        self,
+        df_data: "DataFrame",
+        row: Optional[int] = None,
+        col: Optional[int] = None,
+    ) -> None:
+        """Add rangebreaks to hide datetime gaps on the xaxis.
+
+        Parameters
+        ----------
+        df_data : `DataFrame`
+            The dataframe with the data.
+        row : `int`, optional
+            The row of the subplot to hide the gaps, by default None
+        col : `int`, optional
+            The column of the subplot to hide the gaps, by default None
+        """
+        # pylint: disable=import-outside-toplevel
+        from pandas import date_range, to_datetime
+
+        # We get the min and max dates
+        dt_start, dt_end = df_data.index.min(), df_data.index.max()
+        rangebreaks: List[Dict[str, Any]] = []
+
+        # if weekly or monthly data, we don't need to hide gaps
+        # this prevents distortions in the plot
+        check_freq = df_data.index.to_series().diff(-5).dt.days.abs().mode().iloc[0]
+        if check_freq > 7:
+            return
+
+        # We get the missing days
+        is_daily = df_data.index[-1].time() == df_data.index[-2].time()
+        dt_days = date_range(start=dt_start, end=dt_end, normalize=True)
+
+        # We get the dates that are missing
+        dt_missing_days = list(
+            set(dt_days.strftime("%Y-%m-%d")) - set(df_data.index.strftime("%Y-%m-%d"))
+        )
+        dt_missing_days = to_datetime(dt_missing_days)
+
+        if len(dt_missing_days) < 2_000:
+            rangebreaks = [dict(values=dt_missing_days)]
+
+        df_data = df_data.sort_index()
+        # We add a rangebreak if the first and second time are not the same
+        # since daily data will have the same time (00:00)
+        if not is_daily:
+            for i in range(len(df_data) - 1):
+                if df_data.index[i + 1] - df_data.index[i] > timedelta(hours=2):
+                    rangebreaks.insert(
+                        0,
+                        dict(
+                            bounds=[
+                                df_data.index[i]
+                                + timedelta(minutes=60 - df_data.index[i].minute),
+                                df_data.index[i + 1],
+                            ]
+                        ),
+                    )
+
+        self.update_xaxes(rangebreaks=rangebreaks, row=row, col=col)
+
+    def add_rangebreaks(self) -> None:
+        """Add rangebreaks to hide datetime gaps on the xaxis."""
+        # pylint: disable=import-outside-toplevel
+        from numpy import concatenate
+        from pandas import DataFrame, to_datetime
+
+        if self.get_dateindex() is None:
+            return
+
+        for row, row_dict in self._subplot_xdates.items():
+            for col, values in row_dict.items():
+                try:
+                    x_values = to_datetime(concatenate(values)).to_pydatetime()
+                    self.hide_date_gaps(
+                        DataFrame(index=x_values.tolist()),
+                        row=row,
+                        col=col,
+                    )
+                except ValueError:
+                    continue
+
+    def to_subplot(
+        self,
+        subplot: "OpenBBFigure",
+        row: int,
+        col: int,
+        secondary_y: bool = False,
+        **kwargs,
+    ) -> "OpenBBFigure":
+        """Return the figure as a subplot of another figure.
+
+        Parameters
+        ----------
+        subplot : `plotly.graph_objects.Figure`
+            Figure object created with `OpenBBFigure.create_subplots` / `plotly.subplots.make_subplots`
+        row : `int`
+            Row number
+        col : `int`
+            Column number
+        secondary_y : `bool`, optional
+            Whether to use the secondary y axis, by default False
+
+        Returns
+        -------
+        `plotly.graph_objects.Figure`
+            The subplot with the figure added
+        """
+        for trace in self.data:
+            if kwargs:
+                trace.update(**kwargs)
+
+            subplot.add_trace(trace, row=row, col=col, secondary_y=secondary_y)
+            subplot.set_xaxis_title(self.layout.xaxis.title.text, row=row, col=col)
+            subplot.set_yaxis_title(self.layout.yaxis.title.text, row=row, col=col)
+
+        return subplot
+
+    def to_html(self, *args, **kwargs) -> str:
+        """Return the figure as HTML."""
+        self.update_traces(marker_line_width=0.0001, selector=dict(type="bar"))
+        kwargs.update(
+            dict(
+                config={
+                    "scrollZoom": True,
+                    "displaylogo": False,
+                    "editable": True,
+                    "displayModeBar": "hover",
+                },
+                include_plotlyjs=kwargs.pop("include_plotlyjs", False),
+                full_html=False,
+            )
+        )
+        self._apply_feature_flags()
+        self._xaxis_tickformatstops()
+
+        if not self._backend.isatty and self.data[0].type != "table":
+            for key, max_val in zip(["l", "r", "b", "t"], [60, 60, 80, 40]):
+                if key in self.layout.margin and (
+                    self.layout.margin[key] is None
+                    or (self.layout.margin[key] > max_val)
+                ):
+                    self.layout.margin[key] = max_val
+
+            orientation = "v" if self.layout.legend.orientation is None else "h"
+
+            for annotation in self.select_annotations(
+                selector=dict(x=0, xanchor="right")
+            ):
+                annotation.font.size = (
+                    annotation.font.size - 1.8 if annotation.font.size else 10
+                )
+
+            for trace in self.select_traces(
+                lambda trace: hasattr(trace, "legend") and trace.legend is not None
+            ):
+                if trace.legend in self.layout:
+                    self.layout[trace.legend].font.size = 12
+
+            self.update_layout(
+                legend=dict(orientation=orientation, font=dict(size=12)),
+                font=dict(size=14),
+            )
+            self.update_xaxes(tickfont=dict(size=13))
+            self.update_yaxes(tickfont=dict(size=13))
+
+        return super().to_html(*args, **kwargs)
+
+    def to_plotly_json(self) -> dict:
+        """Serialize, then deserialize, the figure to JSON. Returns as a Python dictionary."""
+        fig = json.loads(self.to_json())
+
+        fig.update(
+            {
+                "config": {
+                    "displayModeBar": "hover",
+                    "displaylogo": False,
+                    "editable": True,
+                    "scrollZoom": True,
+                }
+            }
+        )
+        return fig
+
+    @staticmethod
+    def row_colors(data: "DataFrame") -> Optional[List[str]]:
+        """Return the row colors of the table.
+
+        Parameters
+        ----------
+        data : `DataFrame`
+            The dataframe
+
+        Returns
+        -------
+        `list`
+            The list of colors
+        """
+        row_count = len(data)
+        # we determine how many rows in `data` and then create a list with alternating
+        # row colors
+        row_odd_count = floor(row_count / 2) + row_count % 2
+        row_even_count = floor(row_count / 2)
+        odd_list = [PLT_TBL_ROW_COLORS[0]] * row_odd_count
+        even_list = [PLT_TBL_ROW_COLORS[1]] * row_even_count
+        color_list = [x for y in zip(odd_list, even_list) for x in y]
+        if row_odd_count > row_even_count:
+            color_list.append(PLT_TBL_ROW_COLORS[0])
+
+        return color_list
+
+    @staticmethod
+    def _tbl_values(data: "DataFrame", print_index: bool) -> Tuple[List[str], List]:
+        """Return the values of the table.
+
+        Parameters
+        ----------
+        data : `DataFrame`
+            The dataframe to convert
+        print_index : `bool`
+            Whether to print the index
+
+        Returns
+        -------
+        `tuple`
+            The header values and the cell values
+        """
+        if print_index:
+            header_values = list(
+                [data.index.name if data.index.name is not None else "", *data.columns]
+            )
+            cell_values = [data.index, *[data[col] for col in data]]
+
+        else:
+            header_values = data.columns.to_list()
+            cell_values = [data[col] for col in data]
+
+        header_values = [f"<b>{x}</b>" for x in header_values]
+
+        return header_values, cell_values
+
+    @classmethod
+    def to_table(
+        cls,
+        data: "DataFrame",
+        columnwidth: Optional[List[Union[int, float]]] = None,
+        print_index: bool = True,
+        **kwargs,
+    ) -> "OpenBBFigure":
+        """Convert a dataframe to a table figure.
+
+        Parameters
+        ----------
+        data : `DataFrame`
+            The dataframe to convert
+        columnwidth : `list`, optional
+            The width of each column, by default None (auto)
+        print_index : `bool`, optional
+            Whether to print the index, by default True
+        height : `int`, optional
+            The height of the table, by default len(data.index) * 28 + 25
+        width : `int`, optional
+            The width of the table, by default sum(columnwidth) * 8.7
+
+        Returns
+        -------
+        `plotly.graph_objects.Figure`
+            The figure as a table
+        """
+        if not columnwidth:
+            # we get the length of each column using the max length of the column
+            # name and the max length of the column values as the column width
+            columnwidth = [
+                max(len(str(data[col].name)), data[col].astype(str).str.len().max())
+                for col in data.columns
+            ]
+            # we add the length of the index column if we are printing the index
+            if print_index:
+                columnwidth.insert(
+                    0,
+                    max(
+                        len(str(data.index.name)),
+                        data.index.astype(str).str.len().max(),
+                    ),
+                )
+
+            # we add a percentage of max to the min column width
+            columnwidth = [
+                int(x + (max(columnwidth) - min(columnwidth)) * 0.2)
+                for x in columnwidth
+            ]
+
+        header_values, cell_values = cls._tbl_values(data, print_index)
+
+        if (height := kwargs.get("height")) and height < len(data.index) * 28 + 25:
+            kwargs.pop("height")
+        if (width := kwargs.get("width")) and width < sum(columnwidth) * 8.7:
+            kwargs.pop("width")
+
+        height = kwargs.pop("height", len(data.index) * 28 + 25)
+        width = kwargs.pop("width", sum(columnwidth) * 8.7)
+
+        fig = OpenBBFigure()
+        fig.add_table(
+            header=dict(values=header_values),
+            cells=dict(
+                values=cell_values,
+                align="left",
+                height=25,
+            ),
+            columnwidth=columnwidth,
+            **kwargs,
+        )
+        fig.update_layout(
+            height=height,
+            width=width,
+            template="openbb_tables",
+            margin=dict(l=0, r=0, b=0, t=0, pad=0),
+            font=dict(size=14),
+        )
+
+        return fig
+
+    def _adjust_margins(self) -> None:
+        """Adjust the margins of the figure."""
+        if self._margin_adjusted:
+            return
+
+        margin_add = (
+            dict(l=80, r=60, b=80, t=40, pad=0)
+            if not self._has_secondary_y or not self.has_subplots
+            else dict(l=60, r=50, b=85, t=40, pad=0)
+        )
+
+        # We adjust margins
+        if self._backend.isatty:
+            for key in ["l", "r", "b", "t", "pad"]:
+                if key in self.layout.margin and self.layout.margin[key] is not None:
+                    self.layout.margin[key] += margin_add.get(key, 0)
+                else:
+                    self.layout.margin[key] = margin_add.get(key, 0)
+
+        if not self._backend.isatty:
+            org_margin = self.layout.margin
+            margin = dict(l=40, r=60, b=80, t=50)
+            for key, max_val in zip(["l", "r", "b", "t"], [60, 50, 80, 50]):
+                org = org_margin[key] or 0
+                if (org + margin[key]) > max_val:
+                    self.layout.margin[key] = max_val
+                else:
+                    self.layout.margin[key] = org + margin[key]
+
+        self._margin_adjusted = True
+
+    # pylint: disable=import-outside-toplevel
+    def _add_cmd_source(self, command_location: Optional[str] = "") -> None:
+        """Set the watermark for OpenBB Terminal."""
+        if command_location:
+            yaxis = self.layout.yaxis
+            yaxis2 = self.layout.yaxis2 if hasattr(self.layout, "yaxis2") else None
+            xshift = -70 if yaxis.side == "right" else -80
+
+            if self.layout.margin["l"] > 100:
+                xshift -= 50 if self._added_logscale else 40
+
+            if (
+                yaxis2
+                and (yaxis.title.text and yaxis2.title.text)
+                and (yaxis.side == "left" or yaxis2.side == "left")
+            ):
+                self.layout.margin["l"] += 20
+
+            if (yaxis2 and yaxis2.side == "left") or yaxis.side == "left":
+                title = (
+                    yaxis.title.text
+                    if not yaxis2 or yaxis2.side != "left"
+                    else yaxis2.title.text
+                )
+                xshift = -110 if not title else -135
+                self.layout.margin["l"] += 60
+
+            self.add_annotation(
+                x=0,
+                y=0.5,
+                yref="paper",
+                xref="paper",
+                text=command_location,
+                textangle=-90,
+                font_size=24,
+                font_color="gray" if self._theme.mapbox_style == "dark" else "black",
+                opacity=0.5,
+                yanchor="middle",
+                xanchor="left",
+                xshift=xshift + self.cmd_xshift,
+            )
+
+    # pylint: disable=import-outside-toplevel
+    def _apply_feature_flags(self) -> None:
+        """Apply watermark and command source annotations."""
+        if self._feature_flags_applied:
+            return
+
+        self._add_cmd_source()
+
+        self._feature_flags_applied = True
+
+    def add_logscale_menus(self, yaxis: str = "yaxis") -> None:
+        """Set the menus for the figure."""
+        self._added_logscale = True
+        bg_color = "#000000" if self._theme.mapbox_style == "dark" else "#FFFFFF"  # type: ignore
+        font_color = "#FFFFFF" if self._theme.mapbox_style == "dark" else "#000000"  # type: ignore
+        self.update_layout(
+            xaxis=dict(
+                rangeslider=dict(visible=False),
+                rangeselector=dict(
+                    bgcolor=bg_color,
+                    font=dict(color=font_color),
+                    buttons=list(
+                        [
+                            dict(
+                                count=1,
+                                label="1M",
+                                step="month",
+                                stepmode="backward",
+                            ),
+                            dict(
+                                count=3,
+                                label="3M",
+                                step="month",
+                                stepmode="backward",
+                            ),
+                            dict(count=1, label="YTD", step="year", stepmode="todate"),
+                            dict(
+                                count=1,
+                                label="1y",
+                                step="year",
+                                stepmode="backward",
+                            ),
+                            dict(step="all"),
+                        ]
+                    ),
+                ),
+            ),
+            bargap=0,
+            bargroupgap=0,
+        )
+
+        self.update_layout(
+            updatemenus=[
+                dict(
+                    bgcolor=bg_color,
+                    font=dict(color=font_color, size=14),
+                    buttons=[
+                        dict(
+                            label="linear   ",
+                            method="relayout",
+                            args=[{f"{yaxis}.type": "linear"}],
+                        ),
+                        dict(
+                            label="log",
+                            method="relayout",
+                            args=[{f"{yaxis}.type": "log"}],
+                        ),
+                    ],
+                    y=1.07,
+                    x=-0.01,
+                )
+            ],
+        )
+
+    def add_corr_plot(  # pylint: disable=too-many-arguments
+        self,
+        series: "DataFrame",
+        max_lag: int = 20,
+        m: Optional[int] = None,
+        alpha: Optional[float] = 0.05,
+        marker: Optional[dict] = None,
+        row: Optional[int] = None,
+        col: Optional[int] = None,
+        pacf: bool = False,
+        **kwargs,
+    ) -> None:
+        """Add a correlation plot to a figure object.
+
+        Parameters
+        ----------
+        fig : OpenBBFigure
+            Figure object to add plot to
+        series : DataFrame
+            Dataframe to look at
+        max_lag : int, optional
+            Number of lags to look at, by default 15
+        m: Optional[int]
+            Optionally, a time lag to highlight on the plot. Default is none.
+        alpha: Optional[float]
+            Optionally, a significance level to highlight on the plot. Default is 0.05.
+        row : int, optional
+            Row to add plot to, by default None
+        col : int, optional
+            Column to add plot to, by default None
+        pacf : bool, optional
+            Flag to indicate whether to use partial autocorrelation or not, by default False
+        """
+        # pylint: disable=import-outside-toplevel
+        import statsmodels.api as sm  # noqa
+        from numpy import arange, asanyarray, ceil, log10, isscalar  # noqa
+
+        mode = "markers+lines" if marker else "lines"
+        line = kwargs.pop("line", None)
+
+        def _prepare_data_corr_plot(x, lags):
+            zero = True
+            irregular = False
+            if lags is None:
+                # GH 4663 - use a sensible default value
+                nobs = x.shape[0]
+                lim = min(int(ceil(10 * log10(nobs))), nobs - 1)
+                lags = arange(not zero, lim + 1)
+            elif isscalar(lags):
+                lags = arange(
+                    not zero, int(lags) + 1  # type: ignore
+                )  # +1 for zero lag
+            else:
+                irregular = True
+                lags = asanyarray(lags).astype(int)
+            nlags = lags.max(0)
+
+            return lags, nlags, irregular
+
+        lags, nlags, irregular = _prepare_data_corr_plot(series, max_lag)
+
+        callback = sm.tsa.stattools.pacf if pacf else sm.tsa.stattools.acf
+        if not pacf:
+            kwargs.update(dict(fft=False))
+
+        acf_x = callback(
+            series,
+            nlags=nlags,
+            alpha=alpha,
+            **kwargs,
+        )
+
+        acf_x, confint = acf_x[:2] if not pacf else acf_x
+
+        if irregular:
+            acf_x = acf_x[lags]
+
+        try:
+            confint = confint[lags]
+            if lags[0] == 0:
+                lags = lags[1:]
+                confint = confint[1:]
+                acf_x = acf_x[1:]
+            lags = lags.astype(float)
+            lags[0] -= 0.5
+            lags[-1] += 0.5
+
+            upp_band = confint[:, 0] - acf_x
+            low_band = confint[:, 1] - acf_x
+
+            # pylint: disable=C0200
+            for x in range(len(acf_x)):
+                self.add_scatter(
+                    x=(x, x),
+                    y=(0, acf_x[x]),
+                    mode=mode,
+                    marker=marker,
+                    line=line,
+                    line_width=(2 if m is not None and x == m else 1),
+                    row=row,
+                    col=col,
+                )
+
+            self.add_scatter(
+                x=lags,
+                y=upp_band,
+                mode="lines",
+                line_color="rgba(0, 0, 0, 0)",
+                opacity=0,
+                row=row,
+                col=col,
+            )
+
+            self.add_scatter(
+                x=lags,
+                y=low_band,
+                mode="lines",
+                fillcolor="rgba(255, 217, 0, 0.30)",
+                fill="tonexty",
+                line_color="rgba(0, 0, 0, 0.0)",
+                opacity=0,
+                row=row,
+                col=col,
+            )
+            self.add_scatter(
+                x=[0, max_lag + 1],
+                y=[0, 0],
+                mode="lines",
+                line_color="white",
+                row=row,
+                col=col,
+            )
+            self.update_traces(showlegend=False)
+
+        except ValueError:
+            pass

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/__init__.py

@@ -0,0 +1 @@
+"""Plotly TA core package."""

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/base.py

@@ -0,0 +1,220 @@
+"""Base class for charting plugins."""
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Type,
+    Union,
+)
+
+from .data_classes import ChartIndicators, TAIndicator
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+def columns_regex(df_ta: "pd.DataFrame", name: str) -> List[str]:
+    """Return columns that match regex name."""
+    column_name = df_ta.filter(regex=rf"{name}(?=[^\d]|$)").columns.tolist()
+
+    return column_name
+
+
+class Indicator:
+    """Class for technical indicator."""
+
+    def __init__(
+        self,
+        func: Callable,
+        name: str = "",
+        **attrs: Any,
+    ) -> None:
+        """Initialize the indicator."""
+        self.func = func
+        self.name = name
+        self.attrs = attrs
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Call the indicator function."""
+        return self.func(*args, **kwargs)
+
+
+class PluginMeta(type):
+    """Metaclass for all Plotly plugins."""
+
+    __indicators__: List[Indicator] = []
+    __static_methods__: list = []
+    __ma_mode__: List[str] = []
+    __inchart__: List[str] = []
+    __subplots__: List[str] = []
+
+    def __new__(mcs: Type["PluginMeta"], *args: Any, **kwargs: Any) -> "PluginMeta":
+        """Create a new instance of the class."""
+        name, bases, attrs = args
+        indicators: Dict[str, Indicator] = {}
+        cls_attrs: Dict[str, list] = {
+            "__ma_mode__": [],
+            "__inchart__": [],
+            "__subplots__": [],
+        }
+        new_cls = super().__new__(mcs, name, bases, attrs, **kwargs)
+        for base in reversed(new_cls.__mro__):
+            for elem, value in base.__dict__.items():
+                if elem in indicators:
+                    del indicators[elem]
+
+                is_static_method = isinstance(value, staticmethod)
+                if is_static_method:
+                    value = value.__func__  # noqa: PLW2901
+                if isinstance(value, Indicator):
+                    if is_static_method:
+                        raise TypeError(
+                            f"Indicator {value.name} can't be a static method"
+                        )
+                    indicators[value.name] = value
+                elif is_static_method and elem not in new_cls.__static_methods__:
+                    new_cls.__static_methods__.append(elem)
+
+                if elem in ["__ma_mode__", "__inchart__", "__subplots__"]:
+                    cls_attrs[elem].extend(value)
+
+        new_cls.__indicators__ = list(indicators.values())
+        new_cls.__static_methods__ = list(set(new_cls.__static_methods__))
+        new_cls.__ma_mode__ = list(set(cls_attrs["__ma_mode__"]))
+        new_cls.__inchart__ = list(set(cls_attrs["__inchart__"]))
+        new_cls.__subplots__ = list(set(cls_attrs["__subplots__"]))
+
+        return new_cls
+
+    def __iter__(cls: Type["PluginMeta"]) -> Iterator[Indicator]:  # type: ignore
+        """Iterate over the indicators."""
+        return iter(cls.__indicators__)
+
+    # pylint: disable=unused-argument
+    def __init__(cls, *args: Any, **kwargs: Any) -> None:
+        """Initialize the class."""
+        super().__init__(*args, **kwargs)
+
+
+class PltTA(metaclass=PluginMeta):
+    """The base class that all Plotly plugins must inherit from."""
+
+    indicators: ChartIndicators
+    intraday: bool = False
+    df_stock: Union["pd.DataFrame", "pd.Series"]
+    df_ta: Optional["pd.DataFrame"] = None
+    df_fib: "pd.DataFrame"
+    close_column: Optional[str] = "close"
+    params: Optional[Dict[str, TAIndicator]] = {}
+    inchart_colors: List[str] = []
+    show_volume: bool = True
+
+    __static_methods__: list = []
+    __indicators__: List[Indicator] = []
+    __ma_mode__: List[str] = []
+    __inchart__: List[str] = []
+    __subplots__: List[str] = []
+
+    # pylint: disable=unused-argument
+    def __new__(cls, *args: Any, **kwargs: Any) -> "PltTA":
+        """Create a new instance of the class."""
+        if cls is PltTA:
+            raise TypeError("Can't instantiate abstract class Plugin directly")
+        self = super().__new__(cls)
+
+        static_methods = cls.__static_methods__
+        indicators = cls.__indicators__
+
+        for item in indicators:
+            # we make sure that the indicator is bound to the instance
+            if not hasattr(self, item.name):
+                setattr(self, item.name, item.func.__get__(self, cls))
+
+        for static_method in static_methods:
+            if not hasattr(self, static_method):
+                setattr(self, static_method, staticmethod(getattr(self, static_method)))
+
+        for attr, value in cls.__dict__.items():
+            if attr in [
+                "__ma_mode__",
+                "__inchart__",
+                "__subplots__",
+            ] and value not in getattr(self, attr):
+                getattr(self, attr).extend(value)
+
+        return self
+
+    @property
+    def ma_mode(self) -> List[str]:
+        """Moving average mode."""
+        return list(set(self.__ma_mode__))
+
+    @ma_mode.setter
+    def ma_mode(self, value: List[str]):
+        self.__ma_mode__ = value
+
+    def add_plugins(self, plugins: List["PltTA"]) -> None:
+        """Add plugins to current instance."""
+        for plugin in plugins:
+            for item in plugin.__indicators__:
+                # pylint: disable=unnecessary-dunder-call
+                if not hasattr(self, item.name):
+                    setattr(self, item.name, item.func.__get__(self, type(self)))
+                    self.__indicators__.append(item)
+
+            for static_method in plugin.__static_methods__:
+                if not hasattr(self, static_method):
+                    setattr(
+                        self, static_method, staticmethod(getattr(self, static_method))
+                    )
+            for attr, value in plugin.__dict__.items():
+                if attr in [
+                    "__ma_mode__",
+                    "__inchart__",
+                    "__subplots__",
+                ] and value not in getattr(self, attr):
+                    getattr(self, attr).extend(value)
+
+    def remove_plugins(self, plugins: List["PltTA"]) -> None:
+        """Remove plugins from current instance."""
+        for plugin in plugins:
+            for item in plugin.__indicators__:
+                delattr(self, item.name)
+                self.__indicators__.remove(item)
+
+            for static_method in plugin.__static_methods__:
+                delattr(self, static_method)
+
+    def __iter__(self) -> Iterator[Indicator]:
+        """Iterate over the indicators."""
+        return iter(self.__indicators__)
+
+    def get_float_precision(self) -> str:
+        """Return f-string precision format."""
+        price = self.df_stock[self.close_column].tail(1).values[0]
+        float_precision = (
+            ",.2f" if price > 1.10 else "" if len(str(price)) < 8 else ".6f"
+        )
+        return float_precision
+
+
+def indicator(
+    name: str = "",
+    **attrs: Any,
+) -> Callable:
+    """Use this decorator for adding indicators to a plugin class."""
+    attrs["name"] = name
+
+    def decorator(func: Callable) -> Indicator:
+        if not attrs.pop("name", ""):
+            name = func.__name__
+
+        # pylint: disable=possibly-used-before-assignment
+        return Indicator(func, name, **attrs)
+
+    return decorator

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/data_classes.py

@@ -0,0 +1,395 @@
+"""Dataclasses for the charting extension."""
+
+# pylint: disable=C0302,R0915,R0914,R0913,R0903,R0904
+
+import sys
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    from pandas import DataFrame, Series
+
+# pylint: disable=E1123
+datacls_kwargs = {"slots": True} if sys.version_info >= (3, 10) else {}
+
+
+def columns_regex(df_ta: "DataFrame", name: str) -> List[str]:
+    """Return columns that match regex name."""
+    column_name = df_ta.filter(regex=rf"{name}(?=[^\d]|$)").columns.tolist()
+
+    return column_name
+
+
+@dataclass(**datacls_kwargs)
+class Arguments:
+    """Arguments for technical analysis indicators."""
+
+    label: str
+    values: Any
+
+    def __post_init__(self):
+        """Post init."""
+        if isinstance(self.values, list) and len(self.values) == 1:
+            self.values = self.values[0]
+
+
+@dataclass(**datacls_kwargs)
+class TAIndicator:
+    """Technical analysis indicator."""
+
+    name: Literal[
+        "ad",
+        "adosc",
+        "adx",
+        "aroon",
+        "atr",
+        "cci",
+        "donchian",
+        "fisher",
+        "kc",
+        "obv",
+        "stoch",
+        "vwap",
+        "fib",
+        "srlines",
+        "clenow",
+        "demark",
+        "ichimoku",
+        "sma",
+        "ema",
+        "wma",
+        "hma",
+        "zlma",
+        "rma",
+    ]
+    args: List[Arguments]
+
+    def __iter__(self):
+        """Return iterator."""
+        return iter(self.args)
+
+    def get_args(self, label: str) -> Union[Arguments, None]:
+        """Return arguments by label."""
+        output = None
+        for opt in self.args:
+            if opt.label == label:
+                output = opt
+        return output
+
+    def get_argument_values(self, label: str) -> Union[List[Any], Any]:
+        """Return arguments values by label."""
+        output = []
+        options = self.get_args(label)
+        if options is not None:
+            output = options.values
+        return output
+
+
+@dataclass(**datacls_kwargs)
+class ChartIndicators:
+    """Chart technical analysis indicators."""
+
+    indicators: Optional[List[TAIndicator]] = None
+
+    def get_indicator(self, name: str) -> Union[TAIndicator, None]:
+        """Return indicator with given name."""
+        output = None
+        for indicator in self.indicators:  # type: ignore
+            if indicator.name == name:
+                output = indicator
+        return output
+
+    def get_indicator_args(self, name: str, label: str) -> Union[Arguments, None]:
+        """Return argument values for given indicator and label."""
+        output = None
+        indicator = self.get_indicator(name)
+        if indicator is not None:
+            output = indicator.get_args(label)
+            if output is not None:
+                output = output.values
+        return output
+
+    def get_indicators(self) -> Optional[List[TAIndicator]]:
+        """Return active indicators and their arguments."""
+        return self.indicators
+
+    def get_params(self) -> Dict[str, TAIndicator]:
+        """Return dictionary of active indicators and their arguments."""
+        output = {}
+        if self.indicators:
+            output = {str(indicator.name): indicator for indicator in self.indicators}
+        return output
+
+    def get_active_ids(self) -> List[str]:
+        """Return list of names of active indicators."""
+        active_ids = []
+        if self.indicators:
+            active_ids = [str(indicator.name) for indicator in self.indicators]
+        return active_ids
+
+    def get_arg_names(self, name: str) -> List[str]:
+        """Return list of argument labels for given indicator."""
+        output = []
+        indicator = self.get_indicator(name)
+        if indicator is not None:
+            for opt in indicator.args:
+                output.append(opt.label)
+        return output
+
+    def get_options_dict(self, name: str) -> Dict[str, Optional[Arguments]]:
+        """Return dictionary of argument labels and values for given indicator."""
+        output = None
+        options = self.get_arg_names(name)
+        if options:
+            output = {}
+            for opt in options:
+                output[opt] = self.get_indicator_args(name, opt)
+
+        return output
+
+    @staticmethod
+    def get_available_indicators() -> Tuple[str, ...]:
+        """Return tuple of available indicators."""
+        return tuple(
+            TAIndicator.__annotations__["name"].__args__  # pylint: disable=E1101
+        )
+
+    @classmethod
+    def from_dict(
+        cls, indicators: Dict[str, Dict[str, List[Dict[str, Any]]]]
+    ) -> "ChartIndicators":
+        """Return ChartIndicators from dictionary.
+
+        Example
+        -------
+        ChartIndicators.from_dict(
+            {
+                "ad": {
+                    "args": [
+                        {
+                            "label": "AD_LABEL",
+                            "values": [1, 2, 3],
+                        }
+                    ]
+                }
+            }
+        )
+        """
+        return cls(
+            indicators=[
+                TAIndicator(
+                    name=name,  # type: ignore[arg-type]
+                    args=[
+                        Arguments(label=label, values=values)
+                        for label, values in args.items()
+                    ],
+                )
+                for name, args in indicators.items()
+            ]
+        )
+
+    def to_dataframe(
+        self, df_ta: "DataFrame", ma_mode: Optional[List[str]] = None
+    ) -> "DataFrame":
+        """Calculate technical analysis indicators and return dataframe."""
+        output = df_ta.copy()
+        if not output.empty and self.indicators:
+            try:
+                output = TA_Data(output, self, ma_mode).to_dataframe()
+            except Exception as err:
+                warnings.warn(str(err))
+
+        return output
+
+    def get_indicator_data(self, df_ta: "DataFrame", indicator: TAIndicator, **kwargs):
+        """Return dataframe with technical analysis indicators."""
+        output = None
+        if self.indicators:
+            try:
+                output = TA_Data(df_ta, self).get_indicator_data(indicator, **kwargs)
+            except Exception as err:
+                warnings.warn(str(err))
+
+        return output
+
+    def remove_indicator(self, name: str) -> None:
+        """Remove indicator from active indicators."""
+        if self.indicators:
+            for indicator in self.indicators:
+                if indicator.name == name:
+                    self.indicators.remove(indicator)
+
+
+class TA_DataException(Exception):
+    """Exception for TA_Data."""
+
+
+class TA_Data:
+    """
+    Process technical analysis data.
+
+    Parameters
+    ----------
+    df_ta : DataFrame
+        Dataframe with OHLCV data
+    indicators : Union[ChartIndicators, Dict[str, Dict[str, Any]]]
+        ChartIndicators object or dictionary with indicators and arguments
+        Example:
+            dict(
+                sma=dict(length=[20, 50, 100]),
+                adx=dict(length=14),
+                macd=dict(fast=12, slow=26, signal=9),
+                rsi=dict(length=14),
+            )
+
+    Methods
+    -------
+    to_dataframe()
+        Return dataframe with technical analysis indicators
+    get_indicator_data(indicator: TAIndicator, **kwargs)
+        Return dataframe given indicator and arguments
+    """
+
+    def __init__(
+        self,
+        df_ta: Union["DataFrame", "Series"],
+        indicators: Union[ChartIndicators, Dict[str, Dict[str, Any]]],
+        ma_mode: Optional[List[str]] = None,
+    ):
+        """Initialize."""
+        # pylint: disable=import-outside-toplevel
+        from pandas import DataFrame, Series  # noqa
+        from openbb_charting.core.plotly_ta.ta_helpers import check_columns  # noqa
+
+        if isinstance(df_ta, Series):
+            df_ta = df_ta.to_frame()
+
+        if not isinstance(indicators, ChartIndicators):
+            indicators = ChartIndicators.from_dict(indicators)
+
+        self.df_ta: DataFrame = df_ta
+        self.indicators: ChartIndicators = indicators
+        self.ma_mode: List[str] = ma_mode or ["sma", "ema", "wma", "hma", "zlma", "rma"]
+        self.close_col = check_columns(df_ta)
+        if self.close_col is None:
+            raise ValueError("No close column found in dataframe")
+
+        self.columns: Dict[str, List[str]] = {
+            "ad": ["high", "low", self.close_col, "volume"],
+            "adosc": ["high", "low", self.close_col, "volume"],
+            "adx": ["high", "low", self.close_col],
+            "aroon": ["high", "low"],
+            "atr": ["high", "low", self.close_col],
+            "cci": ["high", "low", self.close_col],
+            "donchian": ["high", "low"],
+            "fisher": ["high", "low"],
+            "kc": ["high", "low", self.close_col],
+            "obv": [self.close_col, "volume"],
+            "stoch": ["high", "low", self.close_col],
+            "vwap": ["high", "low", self.close_col, "volume"],
+        }
+
+        self.has_volume = "volume" in df_ta.columns and bool(df_ta["volume"].sum() > 0)
+
+    def get_indicator_data(self, indicator: TAIndicator, **args) -> "DataFrame":
+        """
+        Return dataframe with indicator data.
+
+        Parameters
+        ----------
+        indicator : TAIndicator
+            TAIndicator object
+        args : dict
+            Arguments for given indicator
+
+        Return
+        -------
+        DataFrame
+            Dataframe with indicator data
+        """
+        # pylint: disable=import-outside-toplevel
+        import pandas_ta as ta
+        from pandas import DataFrame
+
+        output = None
+        if indicator and indicator.name in self.ma_mode:
+            if isinstance(indicator.get_argument_values("length"), list):
+                df_ta = DataFrame()
+
+                for length in indicator.get_argument_values("length"):
+                    df_ma = getattr(ta, indicator.name)(
+                        self.df_ta[self.close_col], length=length
+                    )
+                    df_ta.insert(0, f"{indicator.name.upper()}_{length}", df_ma)
+
+                output = df_ta
+
+            else:
+                output = getattr(ta, indicator.name)(
+                    self.df_ta[self.close_col],
+                    length=indicator.get_argument_values("length"),
+                )
+                if indicator.name == "zlma" and output is not None:
+                    output.name = output.name.replace("ZL_EMA", "ZLMA")
+
+        elif indicator.name == "vwap":
+            ta_columns = self.columns[indicator.name]
+            ta_columns = [self.df_ta[col] for col in ta_columns]  # type: ignore
+
+            output = getattr(ta, indicator.name)(
+                *ta_columns,
+            )
+        elif indicator.name in self.columns:
+            ta_columns = self.columns[indicator.name]
+            ta_columns = [self.df_ta[col] for col in ta_columns]  # type: ignore
+
+            if indicator.get_argument_values("use_open") is True:
+                ta_columns.append(self.df_ta["open"])
+
+            output = getattr(ta, indicator.name)(*ta_columns, **args)
+        else:
+            output = getattr(ta, indicator.name)(self.df_ta[self.close_col], **args)
+
+        # Drop NaN values from output and return None if empty
+        if output is not None:
+            output.dropna(inplace=True)
+            if output.empty:
+                output = None
+
+        return output
+
+    def to_dataframe(self) -> "DataFrame":
+        """Return dataframe with all indicators."""
+        active_indicators = self.indicators.get_indicators()
+
+        if not active_indicators:
+            return None
+
+        output = self.df_ta
+        for indicator in active_indicators:
+            if (
+                indicator.name in self.columns
+                and "volume" in self.columns[indicator.name]
+                and not self.has_volume
+            ):
+                continue
+            if indicator.name in ["fib", "srlines", "clenow", "demark", "ichimoku"]:
+                continue
+            try:
+                indicator_data = self.get_indicator_data(
+                    indicator,
+                    **self.indicators.get_options_dict(indicator.name) or {},
+                )
+            except Exception as e:
+                indicator_data = None
+                raise TA_DataException(
+                    f"Error processing indicator {indicator.name}: {e}"
+                ) from e
+
+            if indicator_data is not None:
+                output = output.join(indicator_data).infer_objects(copy=False)
+                numeric_cols = output.select_dtypes(include=["number"]).columns
+                output[numeric_cols] = output[numeric_cols].interpolate("linear")
+
+        return output

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/__init__.py

@@ -0,0 +1 @@
+"""Plotly TA Plugins."""

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/custom_indicators_plugin.py

@@ -0,0 +1,218 @@
+"""Custom technical indicators."""
+
+import warnings
+from datetime import datetime, timedelta
+
+import numpy as np
+import pandas as pd
+
+from openbb_charting.core.config.openbb_styles import PLT_FIB_COLORWAY
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import PltTA, indicator
+
+
+class Custom(PltTA):
+    """Volatility technical indicators."""
+
+    @indicator()
+    def plot_srlines(self, fig: OpenBBFigure, df_ta: pd.DataFrame):
+        """Add support and resistance lines to plotly figure."""
+        window = self.params["srlines"].get_argument_values("window")  # type: ignore
+        window = window[0] if isinstance(window, list) and len(window) > 0 else 200
+
+        def is_far_from_level(value, levels, df_stock):
+            ave = np.mean(df_stock["high"] - df_stock["low"])
+            return np.sum([abs(value - level) < ave for _, level in levels]) == 0
+
+        def is_support(df, i):
+            cond1 = df["low"][i] < df["low"][i - 1]
+            cond2 = df["low"][i] < df["low"][i + 1]
+            cond3 = df["low"][i + 1] < df["low"][i + 2]
+            cond4 = df["low"][i - 1] < df["low"][i - 2]
+            return cond1 and cond2 and cond3 and cond4
+
+        def is_resistance(df, i):
+            cond1 = df["high"][i] > df["high"][i - 1]
+            cond2 = df["high"][i] > df["high"][i + 1]
+            cond3 = df["high"][i + 1] > df["high"][i + 2]
+            cond4 = df["high"][i - 1] > df["high"][i - 2]
+            return cond1 and cond2 and cond3 and cond4
+
+        df_ta2 = df_ta.copy()
+        today = pd.to_datetime(datetime.now(), unit="ns")
+        start_date = pd.to_datetime(datetime.now() - timedelta(days=window), unit="ns")
+
+        df_ta2 = df_ta2.loc[(df_ta2.index >= start_date) & (df_ta2.index < today)]
+
+        if df_ta2.index[-2].date() != df_ta2.index[-1].date():
+            interval = 1440
+        else:
+            interval = (df_ta2.index[1] - df_ta2.index[0]).seconds / 60
+
+        if interval <= 15:
+            cut_days = 1 if interval < 15 else 2
+            dt_unique_days = df_ta2.index.normalize().unique()  # type: ignore
+            df_ta2 = df_ta2.loc[
+                (df_ta2.index >= pd.to_datetime(dt_unique_days[-cut_days], unit="ns"))
+                & (df_ta2.index < today)
+            ].copy()
+
+        levels: list = []
+        x_range = df_ta2.index[-1].replace(hour=15, minute=59)
+        if interval > 15:
+            x_range = df_ta2.index[-1] + timedelta(days=15)
+            if x_range.weekday() > 4:
+                x_range = x_range + timedelta(days=7 - x_range.weekday())
+
+        elif df_ta2.index[-1] >= today.replace(hour=15, minute=0):
+            x_range = (df_ta2.index[-1] + timedelta(days=1)).replace(hour=11, minute=0)
+            if x_range.weekday() > 4:
+                x_range = x_range + timedelta(days=7 - x_range.weekday())
+
+        for i in range(2, len(df_ta2) - 2):
+            if is_support(df_ta2, i):
+                lv = df_ta2["low"][i]
+                if is_far_from_level(lv, levels, df_ta2):
+                    levels.append((i, lv))
+                    fig.add_scatter(
+                        x=[df_ta.index[0], x_range],
+                        y=[lv, lv],
+                        opacity=0.8,
+                        mode="lines+text",
+                        text=["", f"{lv:{self.get_float_precision()}}"],
+                        textposition="top center",
+                        textfont=dict(
+                            family="Arial Black", color="rgb(120, 70, 200)", size=10
+                        ),
+                        line=dict(
+                            width=2, dash="dash", color="rgba(120, 70, 200, 0.70)"
+                        ),
+                        connectgaps=True,
+                        showlegend=False,
+                        row=1,
+                        col=1,
+                        secondary_y=False,
+                    )
+            elif is_resistance(df_ta2, i):
+                lv = df_ta2["high"][i]
+                if is_far_from_level(lv, levels, df_ta2):
+                    levels.append((i, lv))
+                    fig.add_scatter(
+                        x=[df_ta.index[0], x_range],
+                        y=[lv, lv],
+                        opacity=0.85,
+                        mode="lines+text",
+                        text=["", f"{lv:{self.get_float_precision()}}"],
+                        textposition="top center",
+                        textfont=dict(
+                            family="Arial Black", color="rgb(120, 70, 200)", size=10
+                        ),
+                        line=dict(
+                            width=2, dash="dash", color="rgba(120, 70, 200, 0.70)"
+                        ),
+                        connectgaps=True,
+                        showlegend=False,
+                        row=1,
+                        col=1,
+                        secondary_y=False,
+                    )
+
+        return fig
+
+    @indicator()
+    def plot_fib(self, fig: OpenBBFigure, df_ta: pd.DataFrame):
+        """Add fibonacci to plotly figure."""
+        try:
+            from openbb_technical.helpers import (  # pylint: disable=import-outside-toplevel
+                calculate_fib_levels,
+            )
+        except ImportError:
+            warnings.warn(
+                "In order to use the Fibonacci indicator in your plot,"
+                " you need to install the `openbb-technical` package."
+            )
+            return fig
+
+        limit = self.params["fib"].get_argument_values("limit") or 120  # type: ignore
+        start_date = self.params["fib"].get_argument_values("start_date") or None  # type: ignore
+        end_date = self.params["fib"].get_argument_values("end_date") or None  # type: ignore
+        close = self.params["fib"].get_argument_values("close") or "close"  # type: ignore
+        (
+            df_fib,
+            min_date,
+            max_date,
+            min_pr,
+            max_pr,
+            lvl_text,
+        ) = calculate_fib_levels(
+            df_ta, close, limit, start_date, end_date  # type: ignore
+        )
+        levels = df_fib.Price
+        fibs = [
+            "<b>0</b>",
+            "<b>0.235</b>",
+            "<b>0.382</b>",
+            "<b>0.5</b>",
+            "<b>0.618</b>",
+            "<b>0.65</b>",
+            "<b>1</b>",
+        ]
+        min_date = pd.to_datetime(min_date).to_pydatetime()
+        max_date = pd.to_datetime(max_date).to_pydatetime()
+        self.df_fib = df_fib  # pylint: disable=attribute-defined-outside-init
+
+        fig.add_scatter(
+            x=[min_date, max_date],
+            y=[min_pr, max_pr],
+            opacity=0.85,
+            mode="lines",
+            connectgaps=True,
+            line=PLT_FIB_COLORWAY[8],
+            showlegend=False,
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        df_ta2 = df_ta.copy()
+        interval = 1440
+        if df_ta2.index[-2].date() == df_ta2.index[-1].date():
+            interval = (df_ta2.index[1] - df_ta2.index[0]).seconds / 60
+            dt_unique_days = df_ta2.index.normalize().unique()  # type: ignore
+
+            if interval not in [15, 30, 60] and len(dt_unique_days) <= 3:
+                df_ta2 = df_ta2.loc[
+                    (df_ta2.index >= dt_unique_days[-1])
+                    & (df_ta2.index < datetime.now())
+                ].copy()
+                df_ta2 = df_ta2.between_time("09:30", "20:00").copy()
+
+        for i in range(7):
+            idx_int = 4 if lvl_text == "left" else 5
+            text_pos = f"bottom {lvl_text}" if i != idx_int else f"top {lvl_text}"
+
+            if fibs[i] == "<b>0</b>":
+                text_pos = (
+                    f"top {lvl_text}" if lvl_text != "right" else f"bottom {lvl_text}"
+                )
+            text = ["", f"<b>{fibs[i]} ({levels[i]:{self.get_float_precision()}})</b>"]
+            if lvl_text == "right":
+                text = [text[1], text[0]]
+
+            fig.add_scatter(
+                name=fibs[i],
+                x=[min_date, df_ta2.index.max()],
+                y=[levels[i], levels[i]],
+                opacity=0.85,
+                mode="lines+text",
+                text=text,
+                textposition=text_pos,
+                textfont=dict(PLT_FIB_COLORWAY[7], color=PLT_FIB_COLORWAY[i]),
+                line_color=PLT_FIB_COLORWAY[i],
+                line_width=1.5,
+                showlegend=False,
+                row=1,
+                col=1,
+                secondary_y=False,
+            )
+
+        return fig

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/momentum_plugin.py

@@ -0,0 +1,629 @@
+"""Momentum technical indicators."""
+
+import warnings
+
+import numpy as np
+import pandas as pd
+import pandas_ta as ta
+
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import (
+    PltTA,
+    indicator,
+)
+from openbb_charting.core.plotly_ta.data_classes import (
+    columns_regex,
+)
+
+
+class Momentum(PltTA):
+    """Momentum technical indicators."""
+
+    __subplots__ = ["rsi", "macd", "stoch", "cci", "fisher", "cg"]
+    __inchart__ = ["clenow", "demark", "ichimoku"]
+
+    @indicator()
+    def plot_cci(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add CCI to plotly figure."""
+        cci_col = columns_regex(df_ta, "CCI")[0]
+        dmax = df_ta[cci_col].max()
+        dmin = df_ta[cci_col].min()
+        fig.add_scatter(
+            name="CCI",
+            mode="lines",
+            line=dict(width=1.5, color="#e0b700"),
+            x=df_ta.index,
+            y=df_ta[cci_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_hrect(
+            y0=100,
+            y1=dmax,
+            fillcolor=fig.theme.down_color,
+            opacity=0.2,
+            layer="below",
+            line_width=0,
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hrect(
+            y0=-100,
+            y1=dmin,
+            fillcolor=fig.theme.up_color,
+            opacity=0.2,
+            layer="below",
+            line_width=0,
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hline(
+            y=100,
+            opacity=1,
+            layer="below",
+            line=dict(width=2, color=fig.theme.down_color, dash="dash"),
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hline(
+            y=-100,
+            opacity=1,
+            layer="below",
+            line=dict(width=2, color=fig.theme.up_color, dash="dash"),
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>CCI</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.97,
+            font_size=14,
+            font_color="#e0b700",
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=5, autorange=True)  # type: ignore
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_cg(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add cg to plotly figure."""
+        cg_col = columns_regex(df_ta, "CG")[0]
+        fig.add_scatter(
+            name="CG",
+            mode="lines",
+            line=dict(width=1.5, color="#ffed00"),
+            x=df_ta.index,
+            y=df_ta[cg_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="Signal",
+            mode="lines",
+            line=dict(width=1.5, color="#ef7d00"),
+            x=df_ta.index,
+            y=df_ta[cg_col].shift(1),
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>CG</b>",
+            x=0,
+            xanchor="right",
+            xshift=-10,
+            y=0.97,
+            font_size=14,
+            font_color="#ffed00",
+        )
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="Signal",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.97,
+            yshift=-20,
+            font_size=14,
+            font_color="#ef7d00",
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=5, autorange=True)  # type: ignore
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_clenow(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add current close price to plotly figure."""
+        try:
+            from openbb_technical.helpers import (  # pylint: disable=import-outside-toplevel
+                clenow_momentum,
+            )
+        except ImportError:
+            warnings.warn(
+                "In order to use the Clenow momentum indicator in your plot,"
+                " you need to install the `openbb-technical` package."
+            )
+            return fig, inchart_index
+
+        window = self.params["clenow"].get_argument_values("window") or 90  # type: ignore
+        _, _, fit_data = clenow_momentum(df_ta[self.close_column], window=window)  # type: ignore
+
+        fig.add_scatter(
+            x=df_ta.index[-window:],  # type: ignore
+            y=pow(np.e, fit_data),
+            name="CLenow",
+            mode="lines",
+            line=dict(color=self.inchart_colors[inchart_index], width=2),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text="<b>CLenow</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            font_color=self.inchart_colors[inchart_index],
+            opacity=1,
+        )
+        return fig, inchart_index + 1
+
+    @indicator()
+    def plot_demark(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add demark to plotly figure."""
+        min_val = self.params["demark"].get_argument_values("min_val") or 5  # type: ignore
+
+        demark = ta.td_seq(df_ta[self.close_column], asint=True)
+        demark = demark.set_index(df_ta.index)
+
+        # pylint: disable=unsupported-assignment-operation
+        demark["up"] = demark.TD_SEQ_UPa.apply(
+            lambda x: f"<b>{x}</b>" if x >= min_val else None
+        )
+
+        # pylint: disable=unsupported-assignment-operation
+        demark["down"] = demark.TD_SEQ_DNa.apply(
+            lambda x: f"<b>{x}</b>" if x >= min_val else None
+        )
+
+        # we only keep the values that are not None in up/down columns
+        high = df_ta["high"][demark["up"].notnull()]
+        low = df_ta["low"][demark["down"].notnull()]
+        demark = demark[demark["up"].notnull() | demark["down"].notnull()]
+
+        fig.add_scatter(
+            x=low.index,
+            y=low,
+            name="Demark Down",
+            mode="text",
+            text=demark["down"],
+            textposition="bottom center",
+            textfont=dict(color=fig.theme.down_color, size=14.5),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            x=high.index,
+            y=high,
+            name="Demark Up",
+            mode="text",
+            text=demark["up"],
+            textposition="top center",
+            textfont=dict(color=fig.theme.up_color, size=14.5),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text="<b>Demark</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            font_color=self.inchart_colors[inchart_index],
+            opacity=1,
+        )
+
+        return fig, inchart_index + 1
+
+    @indicator()
+    def plot_fisher(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add fisher to plotly figure."""
+        fishert_col = columns_regex(df_ta, "FISHERT")[0]
+        fishers_col = columns_regex(df_ta, "FISHERTs")[0]
+        fig.add_scatter(
+            name="Fisher",
+            mode="lines",
+            line=dict(width=1.5, color="#e0b700"),
+            x=df_ta.index,
+            y=df_ta[fishert_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="Fisher Signal",
+            mode="lines",
+            line=dict(width=1.5, color="#9467bd"),
+            x=df_ta.index,
+            y=df_ta[fishers_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        dmax = df_ta[fishers_col].max()
+        dmin = df_ta[fishers_col].min()
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>FISHER</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color="#e0b700",
+        )
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>SIGNAL</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.01,
+            font_size=13,
+            font_color="#9467bd",
+        )
+        fig.add_hrect(
+            y0=2,
+            y1=(dmax + 4),
+            fillcolor=fig.theme.down_color,
+            opacity=0.2,
+            layer="below",
+            line_width=0,
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hrect(
+            y0=-2,
+            y1=(dmin - 4),
+            fillcolor=fig.theme.up_color,
+            opacity=0.2,
+            layer="below",
+            line_width=0,
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hline(
+            y=2,
+            fillcolor=fig.theme.down_color,
+            opacity=1,
+            layer="below",
+            line=dict(width=2, color=fig.theme.down_color, dash="dash"),
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hline(
+            y=-2,
+            fillcolor=fig.theme.up_color,
+            opacity=1,
+            layer="below",
+            line=dict(width=2, color=fig.theme.up_color, dash="dash"),
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=5, autorange=True)  # type: ignore
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_macd(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add macd to plotly figure."""
+        fig.add_bar(
+            name="MACD Histogram",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "MACDh")[0]].values,
+            opacity=0.9,
+            marker_color="#1a97ea",
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="MACD",
+            mode="lines",
+            line=dict(width=1.5, color="#9467bd"),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "MACD")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="MACD Signal",
+            mode="lines",
+            line=dict(width=1.5, color="rgb(7, 166, 52)"),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "MACDs")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>MACD</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color="#9467bd",
+        )
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>SIGNAL</b>",
+            x=0,
+            xanchor="right",
+            y=0.70,
+            font_size=13,
+            xshift=-3,
+            font_color="rgb(7, 166, 52)",
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(autorange=True, nticks=5)  # type: ignore
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_rsi(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add rsi to plotly figure."""
+        rsi_col = columns_regex(df_ta, "RSI")[0]
+        fig.add_scatter(
+            name="RSI",
+            mode="lines",
+            line=dict(width=1.5, color="rgb(0, 122, 204, 1)"),
+            x=df_ta.index,
+            y=df_ta[rsi_col].values,
+            opacity=1,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>RSI</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color="rgb(0, 122, 204, 1)",
+        )
+        fig.add_hrect(
+            y0=70,
+            y1=100,
+            fillcolor=fig.theme.down_color,
+            opacity=0.2,
+            layer="below",
+            line_width=0,
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hrect(
+            y0=0,
+            y1=30,
+            fillcolor=fig.theme.up_color,
+            opacity=0.2,
+            layer="below",
+            line_width=0,
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hline(
+            y=70,
+            fillcolor=fig.theme.down_color,
+            opacity=1,
+            layer="below",
+            line=dict(width=2, color=fig.theme.down_color, dash="dash"),
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig.add_hline(
+            y=30,
+            fillcolor=fig.theme.up_color,
+            opacity=1,
+            layer="below",
+            line=dict(width=2, color=fig.theme.up_color, dash="dash"),
+            row=subplot_row,  # type: ignore
+            col=1,  # type: ignore
+            secondary_y=False,
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(tickvals=[0, 30, 70, 100])  # type: ignore
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_stoch(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add stoch to plotly figure."""
+        fig.add_scatter(
+            name="STOCH %K",
+            mode="lines",
+            line=dict(width=1.5, color="#e0b700"),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "STOCHk")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="STOCH %D",
+            mode="lines",
+            line=dict(width=1.5, color="#9467bd", dash="dash"),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "STOCHd")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>STOCH</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color="#e0b700",
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=5, autorange=True)  # type: ignore
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_ichimoku(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Calculate Ichimoku indicator."""
+        conversion_period = (
+            self.params["ichimoku"].get_argument_values("conversion_period") or 9  # type: ignore
+        )
+        base_period = self.params["ichimoku"].get_argument_values("base_period") or 26  # type: ignore
+        lagging_line_period = (
+            self.params["ichimoku"].get_argument_values("lagging_line_period") or 52  # type: ignore
+        )
+        displacement = self.params["ichimoku"].get_argument_values("displacement") or 26  # type: ignore
+
+        # Tenkan-sen (Conversion Line)
+        conversion_line = (
+            df_ta["high"].rolling(window=conversion_period).max()  # type: ignore
+            + df_ta["low"].rolling(window=conversion_period).min()  # type: ignore
+        ) / 2
+
+        # Kijun-sen (Base Line)
+        base_line = (
+            df_ta["high"].rolling(window=base_period).max()  # type: ignore
+            + df_ta["low"].rolling(window=base_period).min()  # type: ignore
+        ) / 2
+
+        # Senkou Span A (Leading Span A)
+        leading_span_a = ((conversion_line + base_line) / 2).shift(displacement)  # type: ignore
+
+        # Senkou Span B (Leading Span B)
+        lagging_line = df_ta[self.close_column].shift(-lagging_line_period)  # type: ignore
+        leading_span_b = (
+            (
+                lagging_line.rolling(window=base_period).max()  # type: ignore
+                + lagging_line.rolling(window=base_period).min()  # type: ignore
+            )
+            / 2
+        ).shift(
+            displacement  # type: ignore
+        )
+
+        # Plot Tenkan-sen and Kijun-sen
+        fig.add_scatter(
+            x=df_ta.index,
+            y=conversion_line,
+            line=dict(color="orange", width=1),
+            name="Tenkan-sen",
+            secondary_y=False,
+            showlegend=True,
+            opacity=1,
+        )
+        fig.add_scatter(
+            x=df_ta.index,
+            y=base_line,
+            line=dict(color="blue", width=1),
+            name="Kijun-sen",
+            secondary_y=False,
+            showlegend=True,
+            opacity=1,
+        )
+
+        # Plot Senkou Span A and Senkou Span B as a filled area
+        fig.add_scatter(
+            x=df_ta.index,
+            y=leading_span_a,
+            line=dict(color="#009600", width=1),
+            fill="tonexty",
+            fillcolor="rgba(0, 150, 0, 0.1)",
+            name="Senkou Span A",
+            secondary_y=False,
+            showlegend=False,
+            opacity=0.2,
+        )
+        fig.add_scatter(
+            x=df_ta.index,
+            y=leading_span_b,
+            line=dict(color="#c80000", width=1),
+            fill="tonexty",
+            fillcolor="rgba(200, 0, 0, 0.1)",
+            name="Senkou Span B",
+            showlegend=False,
+            secondary_y=False,
+            opacity=0.2,
+        )
+
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text="<b><span style='color:#009600'>Ichi</span>"
+            "<span style='color:#c80000'>moku</span></b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            opacity=1,
+        )
+
+        return fig, inchart_index + 1

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/overlap_plugin.py

@@ -0,0 +1,96 @@
+"""Overlap technical indicators plugin for Plotly TA."""
+
+import warnings
+
+import pandas as pd
+
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import (
+    PltTA,
+    indicator,
+)
+from openbb_charting.core.plotly_ta.data_classes import (
+    columns_regex,
+)
+
+
+class Overlap(PltTA):
+    """Overlap technical indicators."""
+
+    __inchart__ = ["vwap"]
+    __ma_mode__ = ["sma", "ema", "wma", "hma", "zlma", "rma"]
+
+    @indicator()
+    def plot_ma(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add moving average to plotly figure."""
+        check_ma = [ma for ma in self.ma_mode if ma in self.indicators.get_active_ids()]
+        if check_ma:
+            for ma in check_ma:
+                column_names = columns_regex(df_ta, ma.upper())
+                try:
+                    for column in column_names:
+                        if df_ta[column].empty:
+                            continue
+
+                        fig.add_scatter(
+                            name=column.replace("RMA", "MA"),
+                            mode="lines",
+                            line=dict(
+                                width=1.2, color=self.inchart_colors[inchart_index]
+                            ),
+                            x=df_ta.index,
+                            y=df_ta[column].values,
+                            opacity=0.9,
+                            connectgaps=True,
+                            row=1,
+                            col=1,
+                            secondary_y=False,
+                        )
+                        fig.add_annotation(
+                            xref="paper",
+                            yref="paper",
+                            text=f"<b>{column.replace('_', '').replace('RMA', 'MA')}</b>",
+                            x=0,
+                            xanchor="right",
+                            xshift=-6,
+                            yshift=-inchart_index * 18,
+                            y=0.98,
+                            font_size=14,
+                            font_color=self.inchart_colors[inchart_index],
+                            opacity=1,
+                        )
+                        inchart_index += 1
+
+                except Exception as e:
+                    warnings.warn(f"Error adding {ma.upper()} to plot - {e}")
+
+        return fig, inchart_index
+
+    @indicator()
+    def plot_vwap(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add vwap to plotly figure."""
+        fig.add_scatter(
+            name=columns_regex(df_ta, "VWAP_")[0],
+            mode="lines",
+            line=dict(width=1.5, color=self.inchart_colors[inchart_index]),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "VWAP_")[0]].values,
+            opacity=0.8,
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text="<b>VWAP</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            font_color=self.inchart_colors[inchart_index],
+        )
+
+        return fig, inchart_index + 1

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/trend_indicators_plugin.py

@@ -0,0 +1,197 @@
+"""Trend technical indicators."""
+
+import pandas as pd
+
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import (
+    PltTA,
+    indicator,
+)
+from openbb_charting.core.plotly_ta.data_classes import (
+    columns_regex,
+)
+
+
+class Trend(PltTA):
+    """Trend technical indicators."""
+
+    __subplots__ = ["adx", "aroon"]
+
+    @indicator()
+    def plot_adx(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add ADX to plotly figure."""
+        fig.add_scatter(
+            name="ADX",
+            mode="lines",
+            line=dict(width=1.5, color="#e0b700"),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "ADX")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="+DI",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.up_color),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "DMP")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="-DI",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.down_color),
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "DMN")[0]].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>ADX</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.97,
+            font_size=14,
+            font_color="#e0b700",
+        )
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text=(
+                f"<span style='color: {fig.theme.up_color}'>D+</span><br>"
+                f"<span style='color: {fig.theme.down_color}'>D-</span>"
+            ),
+            x=0,
+            xanchor="right",
+            xshift=-14,
+            y=0.97,
+            yshift=-20,
+            font_size=14,
+            font_color=fig.theme.up_color,
+        )
+        fig.add_hline(
+            y=25,
+            fillcolor="white",
+            opacity=1,
+            layer="below",
+            line_width=1.5,
+            line=dict(color="white", dash="dash"),
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=5, autorange=True)
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_aroon(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add aroon to plotly figure."""
+        aroon_up_col = columns_regex(df_ta, "AROONU")[0]
+        aroon_down_col = columns_regex(df_ta, "AROOND")[0]
+        aroon_osc_col = columns_regex(df_ta, "AROONOSC")[0]
+        fig.add_scatter(
+            name="Aroon Up",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.up_color),
+            x=df_ta.index,
+            y=df_ta[aroon_up_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name="Aroon Down",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.down_color),
+            x=df_ta.index,
+            y=df_ta[aroon_down_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>Aroon</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=1,
+            font_size=14,
+            font_color="#e0b700",
+        )
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text=(
+                f"<span style='color: {fig.theme.up_color}'>↑</span><br>"
+                f"<span style='color: {fig.theme.down_color}'>↓</span>"
+            ),
+            x=0,
+            xanchor="right",
+            xshift=-14,
+            y=0.75,
+            font_size=14,
+            font_color=fig.theme.down_color,
+        )
+        fig.add_hline(
+            y=50,
+            fillcolor="white",
+            opacity=1,
+            layer="below",
+            line_width=1.5,
+            line=dict(color="white", dash="dash"),
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        subplot_row += 1
+
+        fig.add_scatter(
+            name="Aroon Oscillator",
+            mode="lines",
+            line=dict(width=1.5, color="#e0b700"),
+            x=df_ta.index,
+            y=df_ta[aroon_osc_col].values,
+            connectgaps=True,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>Aroon<br>OSC</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color="#e0b700",
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(
+            tickvals=[-100, 0, 100],
+            ticktext=["-100", "0", "100"],
+            nticks=5,
+            autorange=True,
+        )
+
+        return fig, subplot_row + 1

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/volatility_plugin.py

@@ -0,0 +1,223 @@
+"""Volatility technical indicators plugin for Plotly TA."""
+
+import pandas as pd
+
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import (
+    PltTA,
+    indicator,
+)
+from openbb_charting.core.plotly_ta.data_classes import (
+    columns_regex,
+)
+
+
+class Volatility(PltTA):
+    """Volatility technical indicators."""
+
+    __inchart__ = ["bbands", "donchian", "kc"]
+    __subplots__ = ["atr"]
+
+    @indicator()
+    def plot_atr(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add average true range to plotly figure."""
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'ATR')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "ATR")[0]].values,
+            mode="lines",
+            line=dict(width=1, color=fig.theme.get_colors()[1]),
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>ATR</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color=fig.theme.get_colors()[1],
+        )
+        fig["layout"][f"yaxis{subplot_row}"].update(nticks=5, autorange=True)
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_bbands(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add bollinger bands to plotly figure."""
+        bbands_opacity = 0.8 if fig.theme.plt_style == "light" else 1
+
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'BBU')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "BBU")[0]].values,
+            opacity=bbands_opacity,
+            mode="lines",
+            line=dict(width=1, color=fig.theme.up_color),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'BBL')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "BBL")[0]].values,
+            opacity=bbands_opacity,
+            mode="lines",
+            line=dict(width=1, color=fig.theme.down_color),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'BBM')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "BBM")[0]].values,
+            opacity=1,
+            mode="lines",
+            line=dict(width=1, color=fig.theme.get_colors()[1], dash="dash"),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        bbands_text = (
+            columns_regex(df_ta, "BBL")[0].replace("BBL_", "BB").replace("_", ",")
+        )
+        if float(bbands_text.split(",")[1]) % 1 == 0:
+            bbands_text = bbands_text.split(".")[0]
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text=f"<b>{bbands_text}</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            font_color=fig.theme.get_colors()[1],
+            opacity=0.9,
+        )
+
+        return fig, inchart_index + 1
+
+    @indicator()
+    def plot_donchian(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add donchian channels to plotly figure."""
+        if fig.theme.plt_style == "light":
+            fillcolor = "rgba(239, 103, 137, 0.05)"
+            donchian_opacity = 0.4
+        else:
+            fillcolor = "rgba(239, 103, 137, 0.05)"
+            donchian_opacity = 0.4
+
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'DCU')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "DCU")[0]].values,
+            opacity=donchian_opacity,
+            mode="lines",
+            line=dict(width=0.3, color="#EF6689"),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'DCL')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "DCL")[0]].values,
+            opacity=donchian_opacity,
+            mode="lines",
+            line=dict(width=0.3, color="#EF6689"),
+            fill="tonexty",
+            fillcolor=fillcolor,
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+
+        donchian_text = (
+            columns_regex(df_ta, "DCL")[0]
+            .replace("DCL_", "DC")
+            .replace("_", ",")
+            .split(".")[0]
+        )
+
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text=f"<b>{donchian_text}</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            font_color="#B47DA0",
+            opacity=0.9,
+        )
+
+        return fig, inchart_index + 1
+
+    @indicator()
+    def plot_kc(self, fig: OpenBBFigure, df_ta: pd.DataFrame, inchart_index: int):
+        """Add Keltner channels to plotly figure."""
+        mamode = (self.params["kc"].get_argument_values("mamode") or "ema").lower()  # type: ignore
+
+        if fig.theme.plt_style == "light":
+            fillcolor = "rgba(239, 103, 137, 0.05)"
+            kc_opacity = 0.4
+        else:
+            fillcolor = "rgba(239, 103, 137, 0.05)"
+            kc_opacity = 0.4
+
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'KCU')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "KCU")[0]].values,
+            opacity=kc_opacity,
+            mode="lines",
+            line=dict(width=0.3, color="#EF6689"),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        fig.add_scatter(
+            name=f"{columns_regex(df_ta, 'KCL')[0]}",
+            x=df_ta.index,
+            y=df_ta[columns_regex(df_ta, "KCL")[0]].values,
+            opacity=kc_opacity,
+            mode="lines",
+            line=dict(width=0.3, color="#EF6689"),
+            fill="tonexty",
+            fillcolor=fillcolor,
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+        kctext = (
+            columns_regex(df_ta, "KCL")[0]
+            .replace(f"KCL{mamode[0]}_", "KC")
+            .replace("_", ",")
+            .split(".")[0]
+        )
+        fig.add_annotation(
+            xref="paper",
+            yref="paper",
+            text=f"<b>{kctext}</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            yshift=-inchart_index * 18,
+            y=0.98,
+            font_size=14,
+            font_color="#B47DA0",
+            opacity=0.9,
+        )
+
+        return fig, inchart_index + 1

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/plugins/volume_plugin.py

@@ -0,0 +1,125 @@
+"""Volume technical indicators."""
+
+import pandas as pd
+
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import (
+    PltTA,
+    indicator,
+)
+from openbb_charting.core.plotly_ta.data_classes import (
+    columns_regex,
+)
+
+
+class Volume(PltTA):
+    """Volume technical indicators."""
+
+    __subplots__ = ["ad", "adosc", "obv"]
+
+    # Useless super delegation
+    # def __init__(self, *args, **kwargs):
+    #     super().__init__(*args, **kwargs)
+
+    @indicator()
+    def plot_ad(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add ad to plotly figure."""
+        ad_col = columns_regex(df_ta, "AD")[0]
+        fig.add_scatter(
+            name="AD",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.get_colors()[1]),
+            x=df_ta.index,
+            y=df_ta[ad_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_hline(
+            y=0,
+            fillcolor="white",
+            opacity=1,
+            layer="below",
+            line=dict(color="white", dash="dash", width=2),
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>AD</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color=fig.theme.get_colors()[1],
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=3, autorange=True)
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_adosc(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add adosc to plotly figure."""
+        ad_col = columns_regex(df_ta, "ADOSC")[0]
+        fig.add_scatter(
+            name="ADOSC",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.get_colors()[1]),
+            x=df_ta.index,
+            y=df_ta[ad_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>ADOSC</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color=fig.theme.get_colors()[1],
+        )
+
+        return fig, subplot_row + 1
+
+    @indicator()
+    def plot_obv(self, fig: OpenBBFigure, df_ta: pd.DataFrame, subplot_row: int):
+        """Add obv to plotly figure."""
+        obv_col = columns_regex(df_ta, "OBV")[0]
+        fig.add_scatter(
+            name="OBV",
+            mode="lines",
+            line=dict(width=1.5, color=fig.theme.get_colors()[1]),
+            x=df_ta.index,
+            y=df_ta[obv_col].values,
+            opacity=0.9,
+            row=subplot_row,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_annotation(
+            xref=f"x{subplot_row} domain",
+            yref=f"y{subplot_row + 1} domain",
+            text="<b>OBV</b>",
+            x=0,
+            xanchor="right",
+            xshift=-6,
+            y=0.98,
+            font_size=14,
+            font_color=fig.theme.get_colors()[1],
+        )
+        fig["layout"][f"yaxis{subplot_row + 1}"].update(nticks=5, autorange=True)
+
+        return fig, subplot_row + 1

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/ta_class.py

@@ -0,0 +1,676 @@
+"""Technical Analysis class for Plotly."""
+
+# pylint: disable=R0902,R0916,R0912,R0917  # type: ignore[index, assignment]
+
+import importlib
+import inspect
+import sys
+import warnings
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
+
+from openbb_charting.core.chart_style import ChartStyle
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.base import PltTA
+from openbb_charting.core.plotly_ta.data_classes import ChartIndicators
+from openbb_charting.core.plotly_ta.ta_helpers import check_columns
+
+charting_EXTENSION_PATH = Path(__file__).parent.parent.parent
+CHARTING_INSTALL_PATH = charting_EXTENSION_PATH.parent
+PLUGINS_PATH = Path(__file__).parent / "plugins"
+PLOTLY_TA: Optional["PlotlyTA"] = None
+
+if TYPE_CHECKING:
+    import pandas as pd
+    from openbb_core.app.model.charts.charting_settings import ChartingSettings
+
+
+class PlotlyTA(PltTA):
+    """Plotly Technical Analysis class.
+
+    This class is a singleton. It is created and then reused, to assure
+    the plugins are only loaded once. This is done by overriding the __new__
+    method. The __init__ method is overridden to do nothing, except to clear
+    the internal data structures.
+
+    Attributes
+    ----------
+    inchart_colors (List[str]):
+        List of colors for inchart indicators
+    show_volume (bool):
+        Whether to show the volume subplot
+    ma_mode (List[str]):
+        List of available moving average modes
+    inchart (List[str]):
+        List of available inchart indicators
+    subplots (List[str]):
+        List of available subplots
+
+    StaticMethods
+    -------------
+    plot(
+        df: pd.DataFrame,
+        indicators: ChartIndicators,
+        fig: Optional[OpenBBFigure] = None,
+        symbol: Optional[str] = "",
+        candles: bool = True,
+        volume: bool = True,
+    ) -> OpenBBFigure:
+        Plots the chart with the given indicators
+
+
+    Examples
+    --------
+    >>> from openbb import obb
+    >>> from charting.core.plotly_ta.ta_class import PlotlyTA
+
+    >>> df = obb.equity.price.historical("SPY")
+    >>> indicators = dict(
+    >>>     sma=dict(length=[20, 50, 100]),
+    >>>     adx=dict(length=14),
+    >>>     macd=dict(fast=12, slow=26, signal=9),
+    >>>     rsi=dict(length=14),
+    >>> )
+    >>> fig = PlotlyTA.plot(df, indicators=indicators)
+    >>> fig.show()
+
+    If you want to plot the chart with the same indicators, you can
+    reuse the same instance of the class as follows:
+
+    >>> ta = PlotlyTA()
+    >>> fig = ta.plot(df, indicators=indicators)
+    >>> df2 = obb.equity.price.historical("AAPL")
+    >>> fig2 = ta.plot(df2)
+    >>> fig.show()
+    >>> fig2.show()
+    """
+
+    inchart_colors: List[str] = []
+    plugins: List[Type[PltTA]] = []
+    df_ta: Optional["pd.DataFrame"] = None
+    close_column: Optional[str] = "close"
+    has_volume: bool = True
+    show_volume: bool = True
+    prepost: bool = False
+    charting_settings: Optional["ChartingSettings"] = None
+    theme: Optional[ChartStyle] = None
+
+    def __new__(cls, *args, **kwargs):
+        """Create a new instance of the class.
+
+        Method is overridden to create a singleton instance of the class.
+        """
+        cls.charting_settings = kwargs.pop("charting_settings", cls.charting_settings)
+        cls.theme = cls.setup_theme(
+            chart_style=getattr(cls.charting_settings, "chart_style", ""),
+            user_styles_directory=getattr(
+                cls.charting_settings, "user_styles_directory", ""
+            ),
+        )
+        cls.inchart_colors = cls.theme.get_colors()
+
+        global PLOTLY_TA  # pylint: disable=global-statement # noqa
+        if PLOTLY_TA is None:
+            # Creates the instance of the class and loads the plugins
+            # We set the global variable to the instance of the class so that
+            # the plugins are only loaded once
+            PLOTLY_TA = super().__new__(cls)  # type: ignore[attr-defined, assignment]
+            PLOTLY_TA._locate_plugins(  # type: ignore[attr-defined]
+                getattr(cls.charting_settings, "debug_mode", False)
+            )
+            PLOTLY_TA.add_plugins(PLOTLY_TA.plugins)  # type: ignore[attr-defined, assignment]
+
+        return PLOTLY_TA
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the class.
+
+        Method is overridden to do nothing, except to clear the internal data structures.
+        """
+        if not args and not kwargs:
+            self._clear_data()
+        else:
+            self.df_fib = None  # type: ignore
+            super().__init__(*args, **kwargs)
+
+    @staticmethod
+    def setup_theme(chart_style, user_styles_directory) -> ChartStyle:
+        """Set up theme for charting."""
+        return ChartStyle(chart_style, user_styles_directory)
+
+    @property
+    def ma_mode(self) -> List[str]:
+        """List of available moving average modes."""
+        return list(set(self.__ma_mode__))
+
+    @ma_mode.setter
+    def ma_mode(self, value: List[str]):
+        """Set list of available moving average modes."""
+        self.__ma_mode__ = value
+
+    @property
+    def inchart(self) -> List[str]:
+        """List of available inchart indicators."""
+        return list(set(self.__inchart__))
+
+    @inchart.setter
+    def inchart(self, value: List[str]):
+        """Set list of available inchart indicators."""
+        self.__inchart__ = value
+
+    @property
+    def subplots(self) -> List[str]:
+        """List of available subplots."""
+        return list(set(self.__subplots__))
+
+    @subplots.setter
+    def subplots(self, value: List[str]):
+        """Set list of available subplots."""
+        self.__subplots__ = value
+
+    # pylint: disable=R0913
+    def __plot__(
+        self,
+        df_stock: Union["pd.DataFrame", "pd.Series"],
+        indicators: Optional[Union[ChartIndicators, Dict[str, Dict[str, Any]]]] = None,
+        symbol: str = "",
+        candles: bool = True,
+        volume: bool = True,
+        prepost: bool = False,
+        fig: Optional[OpenBBFigure] = None,
+        volume_ticks_x: int = 7,
+    ) -> OpenBBFigure:
+        """Do not call this directly.
+
+        Use the PlotlyTA.plot() static method instead.
+        """
+        # pylint: disable=import-outside-toplevel
+        import pandas as pd
+
+        if isinstance(df_stock, pd.Series):
+            df_stock = df_stock.to_frame()
+
+        if not isinstance(indicators, ChartIndicators):
+            indicators = ChartIndicators.from_dict(indicators or {})
+
+        # Apply to_datetime to the index in a way that handles daylight savings.
+        df_stock.loc[:, "date"] = df_stock.index  # type: ignore
+        df_stock["date"] = df_stock["date"].apply(pd.to_datetime)
+        df_stock.index = df_stock["date"]  # type: ignore
+        df_stock.drop(columns=["date"], inplace=True)
+
+        self.indicators = indicators
+        self.intraday = df_stock.index[-2].time() != df_stock.index[-1].time()
+        self.df_stock = df_stock.sort_index(ascending=True)
+        self.close_column = check_columns(self.df_stock)
+        self.params = self.indicators.get_params()
+
+        self.has_volume = "volume" in self.df_stock.columns and bool(
+            self.df_stock["volume"].sum() > 0
+        )
+        self.show_volume = volume and self.has_volume
+
+        self.prepost = prepost
+
+        return self.plot_fig(
+            fig=fig, symbol=symbol, candles=candles, volume_ticks_x=volume_ticks_x
+        )
+
+    @staticmethod
+    def plot(
+        df_stock: Union["pd.DataFrame", "pd.Series"],
+        indicators: Optional[Union[ChartIndicators, Dict[str, Dict[str, Any]]]] = None,
+        symbol: str = "",
+        candles: bool = True,
+        volume: bool = True,
+        prepost: bool = False,
+        fig: Optional[OpenBBFigure] = None,
+        volume_ticks_x: int = 7,
+    ) -> OpenBBFigure:
+        """Plot a chart with the given indicators.
+
+        Parameters
+        ----------
+        df_stock : pd.DataFrame
+            Dataframe with stock data
+        indicators : Union[ChartIndicators, Dict[str, Dict[str, Any]]]
+            ChartIndicators object or dictionary with indicators and parameters to plot
+            Example:
+                dict(
+                    sma=dict(length=[20, 50, 100]),
+                    adx=dict(length=14),
+                    macd=dict(fast=12, slow=26, signal=9),
+                    rsi=dict(length=14),
+                )
+        symbol : str, optional
+            Symbol to plot, by default uses the dataframe.name attribute if available or ""
+        candles : bool, optional
+            Plot a candlestick chart, by default True (if False, plots a line chart)
+        volume : bool, optional
+            Plot volume, by default True
+        prepost : bool, optional
+            Plot pre and post market data, by default False
+        fig : OpenBBFigure, optional
+            Plotly figure to plot on, by default None
+        volume_ticks_x : int, optional
+            Number to multiply volume, by default 7
+        """
+        if indicators is None and PLOTLY_TA is not None:
+            indicators = PLOTLY_TA.indicators
+
+        return PlotlyTA().__plot__(  # type: ignore
+            df_stock, indicators, symbol, candles, volume, prepost, fig, volume_ticks_x
+        )
+
+    @staticmethod
+    def _locate_plugins(debug: Optional[bool] = False) -> None:
+        """Locate all the plugins in the plugins folder."""
+        path = (
+            Path(sys.executable).parent
+            if hasattr(sys, "frozen")
+            else CHARTING_INSTALL_PATH
+        )
+        if debug:
+            warnings.warn(f"[bold green]Loading plugins from {path}[/]")
+            warnings.warn("[bold green]Plugins found:[/]")
+
+        for plugin in Path(__file__).parent.glob("plugins/*_plugin.py"):
+            python_path = plugin.relative_to(path).with_suffix("")
+
+            if debug:
+                warnings.warn(f"    [bold red]{plugin.name}[/]")
+                warnings.warn(f"        [bold yellow]{python_path}[/]")
+                warnings.warn(f"        [bold bright_cyan]{__package__}[/]")
+                warnings.warn(f"        [bold magenta]{python_path.parts}[/]")
+                warnings.warn(
+                    f"        [bold bright_magenta]{'.'.join(python_path.parts)}[/]"
+                )
+
+            module = importlib.import_module(
+                ".".join(python_path.parts), package=__package__
+            )
+            for _, obj in inspect.getmembers(module):
+                if (
+                    inspect.isclass(obj)
+                    and issubclass(obj, (PltTA))
+                    and obj != PlotlyTA.__class__
+                ) and obj not in PlotlyTA.plugins:
+                    PlotlyTA.plugins.append(obj)
+
+    def _clear_data(self):
+        """Clear and reset all data to default values."""
+        self.df_stock = None  # type: ignore
+        self.indicators = ChartIndicators.from_dict({})
+        self.params = None
+        self.intraday = False
+        self.show_volume = True
+
+    def calculate_indicators(self):
+        """Return dataframe with all indicators."""
+        return self.indicators.to_dataframe(self.df_stock.copy(), self.ma_mode)  # type: ignore
+
+    def get_subplot(self, subplot: str) -> bool:
+        """Return True if subplots will be able to be plotted with current data."""
+        if subplot == "volume":
+            return self.show_volume
+
+        if subplot in ["ad", "adosc", "obv", "vwap"] and not self.has_volume:
+            self.indicators.remove_indicator(subplot)
+            warnings.warn(
+                f"[bold red]Warning:[/] [yellow]{subplot.upper()}"
+                " requires volume data to be plotted but no volume data was found."
+                " Indicator will not be plotted.[/]"
+            )
+            return False
+
+        output = False
+
+        try:
+            indicator = self.indicators.get_indicator(subplot)
+            if indicator is None:
+                return False
+
+            output = self.indicators.get_indicator_data(
+                self.df_stock.copy(),  # type: ignore
+                indicator,
+                **self.indicators.get_options_dict(indicator.name) or {},
+            )
+            if not isinstance(output, bool):
+                output = output.dropna()  # type: ignore
+
+                if output is None or output.empty:
+                    output = False
+
+            return True
+
+        except Exception:
+            output = False
+
+        return output
+
+    def check_subplots(self, subplots: list) -> list:
+        """Return list of subplots that can be plotted with current data."""
+        output = []
+        for subplot in subplots:
+            if self.get_subplot(subplot):
+                output.append(subplot)
+
+        return output
+
+    def get_fig_settings_dict(self):
+        """Return dictionary with settings for plotly figure."""
+        row_params = {
+            "0": dict(rows=1, row_width=[1]),
+            "1": dict(rows=2, row_width=[0.3, 0.7]),
+            "2": dict(rows=3, row_width=[0.15, 0.15, 0.7]),
+            "3": dict(rows=4, row_width=[0.2, 0.2, 0.2, 0.4]),
+            "4": dict(rows=5, row_width=[0.15, 0.15, 0.15, 0.15, 0.4]),
+        }
+
+        check_active = self.indicators.get_active_ids()
+        subplots = [subplot for subplot in self.subplots if subplot in check_active]
+
+        check_rows = min(len(self.check_subplots(subplots)), 4)
+        check_rows += 1 if "aroon" in subplots and (check_rows + 1) < 5 else 0
+
+        specs = [[{"secondary_y": True}]] + [[{"secondary_y": False}]] * check_rows
+
+        output = row_params.get(str(check_rows), dict(rows=1, row_width=[1]))
+        output.update(dict(cols=1, vertical_spacing=0.04, specs=specs))
+
+        return output
+
+    def init_plot(self, symbol: str = "", candles: bool = True) -> OpenBBFigure:
+        """Create plotly figure with subplots.
+
+        Parameters
+        ----------
+        symbol : str, optional
+            Symbol to plot, by default uses the dataframe.name attribute if available or ""
+        candles : bool, optional
+            Plot a candlestick chart, by default True (if False, plots a line chart)
+
+        Returns
+        -------
+        fig : OpenBBFigure
+            Plotly figure with candlestick/line chart and volume bar chart (if enabled)
+        """
+        fig = OpenBBFigure(charting_settings=self.charting_settings)
+        fig = fig.create_subplots(
+            1,
+            1,
+            shared_xaxes=True,
+            vertical_spacing=0.06,
+            horizontal_spacing=0.01,
+            row_width=[1],
+            specs=[[{"secondary_y": True}]],
+        )
+        cc_linewidth = (
+            0.8 if len(self.df_stock.index) > 500 else 0.9 if self.intraday else 1.1
+        )
+        if candles:
+            fig.add_candlestick(
+                x=self.df_stock.index,
+                open=self.df_stock.open,
+                high=self.df_stock.high,
+                low=self.df_stock.low,
+                close=self.df_stock.close,
+                decreasing=dict(line=dict(width=cc_linewidth)),
+                increasing=dict(line=dict(width=cc_linewidth)),
+                name=f"{symbol}",
+                showlegend=False,
+                row=1,
+                col=1,
+                secondary_y=False,
+                hoverinfo="x+y",
+            )
+        else:
+            fig.add_scatter(
+                x=self.df_stock.index,
+                y=self.df_stock[self.close_column],  # type: ignore
+                name=f"{symbol}",
+                connectgaps=True,
+                row=1,
+                col=1,
+                secondary_y=False,
+            )
+            fig.update_layout(yaxis=dict(nticks=15))
+            if self.theme:
+                self.inchart_colors = self.theme.get_colors()[1:]
+
+        fig.set_title(symbol, x=0.5, y=0.98, xanchor="center", yanchor="top")
+        return fig
+
+    def plot_fig(  # noqa: PLR0912
+        self,
+        fig: Optional[OpenBBFigure] = None,
+        symbol: str = "",
+        candles: bool = True,
+        volume_ticks_x: int = 7,
+    ) -> OpenBBFigure:
+        """Plot indicators on plotly figure.
+
+        Parameters
+        ----------
+        fig : OpenBBFigure, optional
+            Plotly figure to plot indicators on, by default None
+        symbol : str, optional
+            Symbol to plot, by default uses the dataframe.name attribute if available or ""
+        candles : bool, optional
+            Plot a candlestick chart, by default True (if False, plots a line chart)
+        volume_ticks_x : int, optional
+            Number to multiply volume, by default 7
+
+        Returns
+        -------
+        fig : OpenBBFigure
+            Plotly figure with candlestick/line chart and volume bar chart (if enabled)
+        """
+        self.df_ta = self.calculate_indicators()
+
+        symbol = (  # type: ignore
+            self.df_stock.name
+            if hasattr(self.df_stock, "name") and not symbol
+            else symbol
+        )
+
+        figure = self.init_plot(symbol, candles) if fig is None else fig
+        subplot_row, fig_new = 2, {}
+        inchart_index, ma_done = 0, False
+
+        figure = self.process_fig(figure, volume_ticks_x)
+
+        # Aroon indicator is always plotted first since it has 2 subplot rows.
+        # ATR messes up the volume layout so we plot it last.
+        plot_indicators = sorted(
+            self.indicators.get_active_ids(),
+            key=lambda x: (
+                50
+                if x == "aroon"
+                else 1000 if x == "atr" else 999 if x in self.subplots else 1
+            ),
+        )
+
+        for indicator in plot_indicators:
+            try:
+                if indicator in self.subplots:
+                    figure, subplot_row = getattr(self, f"plot_{indicator}")(
+                        figure, self.df_ta, subplot_row
+                    )
+                elif indicator in self.ma_mode or indicator in self.inchart:
+                    if indicator in self.ma_mode:
+                        if ma_done:
+                            continue
+                        indicator, ma_done = "ma", True  # noqa
+
+                    figure, inchart_index = getattr(self, f"plot_{indicator}")(
+                        figure, self.df_ta, inchart_index
+                    )
+                    figure.layout.annotations = None
+                elif indicator in ["fib", "srlines", "demark", "clenow", "ichimoku"]:
+                    figure = getattr(self, f"plot_{indicator}")(figure, self.df_ta)
+                else:
+                    raise ValueError(f"Unknown indicator: {indicator}")
+
+                fig_new.update(figure.to_plotly_json())
+
+                remaining_subplots = (
+                    list(
+                        set(plot_indicators[plot_indicators.index(indicator) + 1 :])
+                        - set(self.inchart)
+                    )
+                    if indicator != "ma"
+                    else []
+                )
+                if subplot_row > 5 and remaining_subplots:
+                    warnings.warn(
+                        f"[bold red]Reached max number of subplots.   "
+                        f"Skipping {', '.join(remaining_subplots)}[/]"
+                    )
+                    break
+            except Exception as e:
+                warnings.warn(f"[bold red]Error plotting {indicator}: {e}[/]")
+                continue
+
+        for row in range(0, subplot_row + 1):
+            figure.update_yaxes(
+                row=row,
+                col=1,
+                secondary_y=False,
+                nticks=15 if subplot_row < 3 else 6,
+                tickfont=dict(size=12),
+            )
+        figure.update_traces(
+            selector=dict(type="scatter", mode="lines"), connectgaps=True
+        )
+        if hasattr(figure, "hide_holidays"):
+            figure.hide_holidays(self.prepost)  # type: ignore
+
+        if not self.show_volume:
+            figure.update_layout(margin=dict(l=20))
+
+        # We remove xaxis labels from all but bottom subplot,
+        # and we make sure they all match the bottom one
+        xbottom = f"y{subplot_row+1}"
+        xaxes = list(figure.select_xaxes())
+        for xa in xaxes:
+            if xa == xaxes[-1]:
+                xa.showticklabels = True
+            if not xa.showticklabels and xa.anchor != xbottom:
+                xa.showticklabels = False
+            if xa.anchor != xbottom:
+                xa.matches = xbottom.replace("y", "x")
+
+        fib_legend_shown = False
+        sr_legend_shown = False
+        for item in figure.data:
+            if item.name:
+                item.name = item.name.replace("_", " ")
+                if "MA " not in item.name:
+                    item.showlegend = False
+                if "<b>" in item.name:
+                    item.name = "Fib"
+                    item.hoverinfo = "none"
+                    item.hoveron = "fills"
+                    item.pop("hovertemplate", None)
+                    item.legendgroup = "Fib"
+                    if not fib_legend_shown:
+                        item.showlegend = True
+                        fib_legend_shown = True
+                if (
+                    "Historical" not in item.name
+                    and "Candlestick" not in item.name
+                    and "Fib" not in item.name
+                    and item.name is not None
+                ):
+                    if (
+                        "MA " in item.name
+                        or "VWAP" in item.name
+                        or "DC" in item.name
+                        or "KC" in item.name
+                        or "-sen" in item.name
+                        or "Senkou" in item.name
+                    ):
+                        item.showlegend = True
+                        item.hoverinfo = "y"
+                        item.hovertemplate = "%{fullData.name}:%{y}<extra></extra>"
+                    else:
+                        item.hovertemplate = "%{y}<extra></extra>"
+            if item.name is None:
+                item.name = "SR Lines"
+                item.hoverinfo = "none"
+                item.hoveron = "fills"
+                item.legendgroup = "SR Lines"
+                item.pop("hovertemplate", None)
+                item.opacity = 0.5
+                if not sr_legend_shown:
+                    item.showlegend = True
+                    sr_legend_shown = True
+
+        if "annotations" in figure.layout:
+            for item in figure.layout.annotations:  # type: ignore
+                item["font"]["size"] = 14
+        figure.update_layout(margin=dict(l=50, r=10, b=10, t=20))
+        return figure
+
+    def process_fig(self, fig: OpenBBFigure, volume_ticks_x: int = 7) -> OpenBBFigure:
+        """Process plotly figure before plotting indicators.
+
+        Parameters
+        ----------
+        fig : OpenBBFigure
+            Plotly figure to process
+        volume_ticks_x : int, optional
+            Number to multiply volume, by default 7
+
+        Returns
+        -------
+        fig : OpenBBFigure
+            Processed plotly figure
+        """
+        new_subplot = OpenBBFigure(charting_settings=self.charting_settings)
+        new_subplot = fig.create_subplots(
+            shared_xaxes=True, **self.get_fig_settings_dict()
+        )
+        subplots: Dict[str, Dict[str, List[Any]]] = {}
+        grid_ref = fig._validate_get_grid_ref()  # pylint: disable=protected-access
+        for r, plot_row in enumerate(grid_ref):
+            for c, plot_refs in enumerate(plot_row):
+                if not plot_refs:
+                    continue
+                for subplot_ref in plot_refs:
+                    if subplot_ref.subplot_type == "xy":
+                        xaxis, yaxis = subplot_ref.layout_keys
+                        xref = xaxis.replace("axis", "")
+                        yref = yaxis.replace("axis", "")
+                        row = r + 1
+                        col = c + 1
+                        subplots.setdefault(xref, {}).setdefault(yref, []).append(
+                            (row, col)
+                        )
+
+        for trace in fig.select_traces():
+            xref, yref = trace.xaxis, trace.yaxis
+            row, col = subplots[xref][yref][0]
+            new_subplot.add_trace(trace, row=row, col=col, secondary_y=False)
+
+        fig_json = fig.to_plotly_json()["layout"]
+        for layout in fig_json:
+            if (
+                isinstance(fig_json[layout], dict)
+                and "domain" in fig_json[layout]
+                and any(x in layout for x in ["xaxis", "yaxis"])
+            ):
+                fig_json[layout]["domain"] = new_subplot.to_plotly_json()["layout"][
+                    layout
+                ]["domain"]
+
+            fig.layout.update({layout: fig_json[layout]})  # type: ignore
+            new_subplot.layout.update({layout: fig.layout[layout]})  # type: ignore
+
+        if self.show_volume:
+            new_subplot.add_inchart_volume(
+                self.df_stock, self.close_column, volume_ticks_x=volume_ticks_x  # type: ignore
+            )
+
+        return new_subplot

openbb_platform/obbject_extensions/charting/openbb_charting/core/plotly_ta/ta_helpers.py

@@ -0,0 +1,53 @@
+"""Helper functions for technical analysis indicators."""
+
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+
+def check_columns(
+    data: "DataFrame", high: bool = True, low: bool = True, close: bool = True
+) -> Optional[str]:
+    """Return the close columns, or None if the dataframe does not have required columns.
+
+    Parameters
+    ----------
+    data: DataFrame
+        The dataframe to check
+    high: bool
+        Whether to check for high column
+    low: bool
+        Whether to check for low column
+    close: bool
+        Whether to check for close column
+
+    Returns
+    -------
+    Optional[str]
+        The name of the close column, none if df is invalid
+    """
+    # pylint: disable=import-outside-toplevel
+    import re
+
+    close_regex = r"(Adj\sClose|adj_close|Close)"
+    # pylint: disable=too-many-boolean-expressions
+    if (
+        (re.findall(r"High", str(data.columns), re.IGNORECASE) is None and high)
+        or (re.findall(r"Low", str(data.columns), re.IGNORECASE) is None and low)
+        or (close_col := re.findall(close_regex, str(data.columns), re.IGNORECASE))
+        is None
+        and close
+    ):
+        raise ValueError(
+            " Please make sure that the columns 'High', 'Low', and 'Close'"
+            " are in the dataframe."
+        )
+
+    close_col = [col for col in close_col if col in data.columns]
+
+    # giving priority to the standard close column
+    if "close" in close_col:
+        return "close"
+
+    return close_col[-1]

openbb_platform/obbject_extensions/charting/openbb_charting/core/to_chart.py

@@ -0,0 +1,68 @@
+"""Module containing the to_chart function."""
+
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    from openbb_charting.core.plotly_ta.data_classes import ChartIndicators  # noqa
+    from openbb_charting.core.openbb_figure import OpenBBFigure  # noqa
+    from pandas import DataFrame, Series  # noqa
+
+
+def to_chart(
+    data: Union["DataFrame", "Series"],
+    indicators: Optional[Union["ChartIndicators", Dict[str, Dict[str, Any]]]] = None,
+    symbol: str = "",
+    candles: bool = True,
+    volume: bool = True,
+    prepost: bool = False,
+    volume_ticks_x: int = 7,
+) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Return the plotly json representation of the chart.
+
+    This function is used so it can be called at the module level and used out of the box,
+    which allows some more flexibility, ease of use and doesn't require the user to know
+    about the PlotlyTA class.
+
+    Parameters
+    ----------
+    data : Union[DataFrame, Series]
+        Data to be plotted.
+    indicators : Optional[Union[ChartIndicators, Dict[str, Dict[str, Any]]]], optional
+        Indicators to be plotted, by default None
+    symbol : str, optional
+        Symbol to be plotted, by default ""
+    candles : bool, optional
+        If True, candles will be plotted, by default True
+    volume : bool, optional
+        If True, volume will be plotted, by default True
+    prepost : bool, optional
+        If True, prepost will be plotted, by default False
+    volume_ticks_x : int, optional
+        Volume ticks, by default 7
+
+    Returns
+    -------
+    Tuple[OpenBBFigure, Dict[str, Any]]
+        Tuple containing the OpenBBFigure and the plotly json representation of the chart.
+    """
+    # pylint: disable=import-outside-toplevel
+    from openbb_charting.core.plotly_ta.ta_class import PlotlyTA
+
+    try:
+        ta = PlotlyTA()
+        fig = ta.plot(
+            df_stock=data,
+            indicators=indicators,
+            symbol=symbol,
+            candles=candles,
+            volume=volume,
+            prepost=prepost,
+            volume_ticks_x=volume_ticks_x,
+        )
+        content = fig.show(external=True).to_plotly_json()
+
+        return fig, content
+    except Exception as e:
+        raise Exception(
+            f"Failed to convert results to chart. Ensure the provided data is a valid time series. {e}"
+        ) from e

openbb_platform/obbject_extensions/charting/openbb_charting/query_params.py

@@ -0,0 +1,852 @@
+"""Charting Extension Query Params."""
+
+# pylint: disable=unused-variable,unused-argument
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from openbb_core.provider.abstract.data import Data
+from openbb_core.provider.abstract.query_params import QueryParams
+from pydantic import Field, model_validator
+
+from openbb_charting.core.plotly_ta.data_classes import ChartIndicators
+
+MAMODES = Literal["ema", "sma", "wma", "hna", "zlma", "rma"]
+
+
+def _get_type_name(t):
+    """Get the type name of a type hint."""
+    if hasattr(t, "__origin__"):
+        if hasattr(t.__origin__, "__name__"):
+            return f"{t.__origin__.__name__}[{', '.join([_get_type_name(arg) for arg in t.__args__])}]"
+        if hasattr(t.__origin__, "_name"):
+            return f"{t.__origin__._name}[{', '.join([_get_type_name(arg) for arg in t.__args__])}]"  # pylint: disable=W0212
+    if isinstance(t, str):
+        return t
+    if hasattr(t, "__name__"):
+        return t.__name__
+    if hasattr(t, "_name"):
+        return t._name  # pylint: disable=W0212
+    return str(t)
+
+
+class BaseQueryParams(QueryParams):
+    """Base Query Parmams Base Model."""
+
+    def __init__(self, **data):
+        """Initialize the BaseQueryParams."""
+        super().__init__(**data)
+        self.__doc__ = self.__repr__()
+
+    def __repr__(self):
+        """Return the string representation of the model."""
+        fields = self.__class__.model_fields
+        repr_str = (
+            "\n"
+            + self.__class__.__name__
+            + "\n\n"
+            + "    Parameters\n"
+            + "    ----------\n"
+            + "\n".join(
+                [
+                    f"\n    {k} : {_get_type_name(v.annotation)}\n        {v.description}".replace(
+                        ". ", ".\n        "
+                    )
+                    for k, v in fields.items()
+                ]
+            )
+        )
+        return repr_str
+
+
+class ChartQueryParams(BaseQueryParams):
+    """ChartParams."""
+
+    data: Optional[Union[Data, List[Data]]] = Field(
+        default=None,
+        description="Filtered versions of the data contained in the original `self.results`."
+        + " Columns should be the same as the original data."
+        + " Example use is to reduce the number of columns, or the length of data, to plot.",
+    )
+
+
+class EquityPricePerformanceChartQueryParams(ChartQueryParams):
+    """Equity Price Performance Chart Query Params."""
+
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+    orientation: Literal["v", "h"] = Field(
+        default="v",
+        description="Orientation of the bars.",
+    )
+    limit: Optional[int] = Field(
+        default=None,
+        description="Limit the number of bars to plot, from the most recent."
+        + " If None, the periods from one-day to five-years will be plotted, if available.",
+    )
+    layout_kwargs: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Additional keyword arguments to pass to the Plotly `update_layout` method.",
+    )
+
+
+class EtfPricePerformanceChartQueryParams(EquityPricePerformanceChartQueryParams):
+    """ETF Price Performance Chart Query Params."""
+
+
+class EtfHoldingsChartQueryParams(ChartQueryParams):
+    """ETF Holdings Chart Query Params."""
+
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+    orientation: Literal["v", "h"] = Field(
+        default="v",
+        description="Orientation of the bars.",
+    )
+    limit: Optional[int] = Field(
+        default=20,
+        description="Limit the number of bars to plot, ranked by top weighting.",
+    )
+    layout_kwargs: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Additional keyword arguments to pass to the Plotly `update_layout` method.",
+    )
+
+
+class EquityPriceHistoricalChartQueryParams(ChartQueryParams):
+    """Equity Historical Price Chart Query Params."""
+
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+    target: Optional[str] = Field(
+        default=None,
+        description="The specific column to target. If supplied, this will override the candles and volume parameters.",
+    )
+    multi_symbol: bool = Field(
+        default=False,
+        description="Flag to indicate whether the data contains multiple symbols."
+        + " This is mostly handled automatically, but if the chart fails to generate try setting this to True.",
+    )
+    same_axis: bool = Field(
+        default=False,
+        description="If True, forces all data to be plotted on the same axis.",
+    )
+    normalize: bool = Field(
+        default=False,
+        description="If True, the data will be normalized and placed on the same axis.",
+    )
+    returns: bool = Field(
+        default=False,
+        description="If True, the cumulative returns for the length of the time series will be calculated and plotted.",
+    )
+    candles: bool = Field(
+        default=True,
+        description="If True, and OHLC exists, and there is only one symbol in the data, candles will be plotted.",
+    )
+    heikin_ashi: bool = Field(
+        default=False,
+        description="If True, and `candles=True`, Heikin Ashi candles will be plotted.",
+    )
+    volume: bool = Field(
+        default=True,
+        description="If True, and volume exists, and `candles=True`, volume will be plotted.",
+    )
+    indicators: Optional[Union[ChartIndicators, Dict[str, Dict[str, Any]]]] = Field(
+        default=None,
+        description="Indicators to be plotted, formatted as a dictionary."
+        + " Data containing multiple symbols will ignore indicators."
+        + """
+        Example:
+            indicators = dict(
+                sma=dict(length=[20,30,50]),
+                adx=dict(length=14),
+                rsi=dict(length=14),
+            )""",
+    )
+
+
+class EconomyFredSeriesChartQueryParams(ChartQueryParams):
+    """FRED Series Chart Query Params."""
+
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+    y1title: Optional[str] = Field(
+        default=None,
+        description="Right Y-axis title.",
+    )
+    y2title: Optional[str] = Field(
+        default=None,
+        description="Left Y-axis title.",
+    )
+    xtitle: Optional[str] = Field(
+        default=None,
+        description="X-axis title.",
+    )
+    dropnan: bool = Field(
+        default=True,
+        description="If True, rows containing NaN will be dropped.",
+    )
+    normalize: bool = Field(
+        default=False,
+        description="If True, the data will be normalized and placed on the same axis.",
+    )
+    allow_unsafe: bool = Field(
+        default=False,
+        description="If True, the method will attempt to pass all supplied data to the chart constructor."
+        + " This can result in unexpected behavior.",
+    )
+    plot_bar: bool = Field(
+        default=False,
+        description="If True, a bar chart will be plotted instead of a line."
+        + " If multiple units of measure are present, they will be normalized and plotted on the same axis.",
+    )
+    barmode: Literal["stack", "group", "relative"] = Field(
+        default="group",
+        description="The mode to use for the bar chart, by default is 'group'."
+        + " Has no effect if `bar=False`.",
+    )
+    layout_kwargs: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Additional keyword arguments to pass to the Plotly `update_layout` method.",
+    )
+
+
+class TechnicalConesChartQueryParams(ChartQueryParams):
+    """Technical Cones Chart Query Params."""
+
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+    symbol: Optional[str] = Field(
+        default=None,
+        description="Symbol represented by the data. Used to label the chart.",
+    )
+
+
+class MAQueryParams(ChartQueryParams):
+    """Moving Average Query Params."""
+
+    target: str = Field(
+        default="close",
+        description="The column to calculate the moving average on.",
+    )
+    index: str = Field(
+        default="date",
+        description="The index column.",
+    )
+    length: Optional[Union[int, List[int]]] = Field(
+        default=50,
+        description="Window length for the moving average."
+        "+ The number is relative to the interval of the time series data.",
+    )
+    offset: Optional[int] = Field(
+        default=0,
+        description="Number of periods to offset for the moving average.",
+    )
+    dropnan: bool = Field(
+        default=False,
+        description="If True, rows containing NaN will be dropped."
+        + " This will reduce the length of the charted data by the longest window.",
+    )
+    symbol: Optional[str] = Field(
+        default=None,
+        description="Symbol represented by the data. Used to label the chart.",
+    )
+
+
+class FixedincomeGovernmentYieldCurve(ChartQueryParams):
+    """Fixed Income Government Yield Curve Chart Query Params."""
+
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+    colors: Optional[List[str]] = Field(
+        default=None,
+        description="List of colors to use for the lines.",
+    )
+    layout_kwargs: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Additional keyword arguments to pass to the Plotly `update_layout` method.",
+    )
+
+
+class TechnicalSMAChartQueryParams(MAQueryParams):
+    """Technical SMA Chart Query Params."""
+
+
+class TechnicalEMAChartQueryParams(MAQueryParams):
+    """Technical EMA Chart Query Params."""
+
+
+class TechnicalHMAChartQueryParams(MAQueryParams):
+    """Technical HMA Chart Query Params."""
+
+
+class TechnicalWMAChartQueryParams(MAQueryParams):
+    """Technical WMA Chart Query Params."""
+
+
+class TechnicalZLMAChartQueryParams(MAQueryParams):
+    """Technical ZLMA Chart Query Params."""
+
+
+class TechnicalADXChartQueryParams(ChartQueryParams):
+    """Technical ADX Chart Query Params."""
+
+    length: Optional[int] = Field(
+        default=50,
+        description="Window length for the ADX, by default is 50.",
+    )
+    scalar: Optional[float] = Field(
+        default=100,
+        description="Scalar to multiply the ADX by, default is 100.",
+    )
+    drift: Optional[int] = Field(
+        default=1,
+        description="Drift value for the ADX, by default is 1.",
+    )
+
+
+class TechnicalArooonChartQueryParams(ChartQueryParams):
+    """Technical Aroon Chart Query Params."""
+
+    length: Optional[int] = Field(
+        default=25,
+        description="Window length for the Aroon, by default is 50.",
+    )
+    scalar: Optional[float] = Field(
+        default=100,
+        description="Scalar to multiply the Aroon by, default is 100.",
+    )
+
+
+class TechnicalMACDChartQueryParams(ChartQueryParams):
+    """Technical MACD Chart Query Params."""
+
+    fast: Optional[int] = Field(
+        default=12,
+        description="Window length for the fast EMA, by default is 12.",
+    )
+    slow: Optional[int] = Field(
+        default=26,
+        description="Window length for the slow EMA, by default is 26.",
+    )
+    signal: Optional[int] = Field(
+        default=9,
+        description="Window length for the signal line, by default is 9.",
+    )
+    scalar: Optional[float] = Field(
+        default=100,
+        description="Scalar to multiply the MACD by, default is 100.",
+    )
+
+
+class TechnicalRSIChartQueryParams(ChartQueryParams):
+    """Technical RSI Chart Query Params."""
+
+    length: Optional[int] = Field(
+        default=14,
+        description="Window length for the RSI, by default is 14.",
+    )
+    scalar: Optional[float] = Field(
+        default=100,
+        description="Scalar to multiply the RSI by, default is 100.",
+    )
+    drift: Optional[int] = Field(
+        default=1,
+        description="Drift value for the RSI, by default is 1.",
+    )
+
+
+class TechnicalRelativeRotationChartQueryParams(ChartQueryParams):
+    """Technical Relative Rotation Chart Query Params."""
+
+    date: Optional[str] = Field(
+        default=None,
+        description="A target end date within the data to use for the chart, by default is the last date in the data.",
+    )
+    show_tails: bool = Field(
+        default=True,
+        description="Show the tails on the chart, by default True.",
+    )
+    tail_periods: Optional[int] = Field(
+        default=16,
+        description="Number of periods to show in the tails, by default 16.",
+    )
+    tail_interval: Literal["day", "week", "month"] = Field(
+        default="week",
+        description="The interval to show the tails, by default 'week'.",
+    )
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the chart.",
+    )
+
+
+class ChartParams:
+    """Chart Query Params."""
+
+    crypto_price_historical = EquityPriceHistoricalChartQueryParams
+    derivatives_futures_historical = EquityPriceHistoricalChartQueryParams
+    equity_price_historical = EquityPriceHistoricalChartQueryParams
+    economy_fred_series = EconomyFredSeriesChartQueryParams
+    equity_price_historical = EquityPriceHistoricalChartQueryParams
+    equity_price_performance = EquityPricePerformanceChartQueryParams
+    etf_historical = EtfPricePerformanceChartQueryParams
+    etf_holdings = EtfHoldingsChartQueryParams
+    etf_price_performance = EquityPricePerformanceChartQueryParams
+    index_price_historical = EquityPriceHistoricalChartQueryParams
+    technical_adx = TechnicalADXChartQueryParams
+    technical_aroon = TechnicalArooonChartQueryParams
+    technical_cones = TechnicalConesChartQueryParams
+    technical_ema = TechnicalEMAChartQueryParams
+    technical_hma = TechnicalHMAChartQueryParams
+    technical_macd = TechnicalMACDChartQueryParams
+    technical_relative_rotation = TechnicalRelativeRotationChartQueryParams
+    technical_rsi = TechnicalRSIChartQueryParams
+    technical_sma = TechnicalSMAChartQueryParams
+    technical_wma = TechnicalWMAChartQueryParams
+    technical_zlma = TechnicalZLMAChartQueryParams
+
+
+class IndicatorsQueryParams(BaseQueryParams):
+    """Indicators Query Params."""
+
+
+class MAIndicatorsQueryParams(IndicatorsQueryParams):
+    """Moving Average Indicators Query Params."""
+
+    length: Union[int, List[int]] = Field(
+        default=50,
+        description="Window length for the moving average, by default is 50."
+        + " The number is relative to the interval of the time series data.",
+    )
+    offset: int = Field(
+        default=0,
+        description="Number of periods to offset for the moving average, by default is 0.",
+    )
+
+
+class SMAIndicatorsQueryParams(MAIndicatorsQueryParams):
+    """Simple Moving Average Indicators Query Params."""
+
+
+class EMAIndicatorsQueryParams(MAIndicatorsQueryParams):
+    """Exponential Moving Average Indicators Query Params."""
+
+
+class HMAIndicatorsQueryParams(MAIndicatorsQueryParams):
+    """Hull Moving Average Indicators Query Params."""
+
+
+class WMAIndicatorsQueryParams(MAIndicatorsQueryParams):
+    """Weighted Moving Average Indicators Query Params."""
+
+
+class ZLMAIndicatorsQueryParams(MAIndicatorsQueryParams):
+    """Zero-Lag Moving Average Indicators Query Params."""
+
+
+class ADIndicatorsQueryParams(IndicatorsQueryParams):
+    """Accumulation/Distribution Indicators Query Params."""
+
+    offset: int = Field(
+        default=0,
+        description="Offset value for the AD, by default is 0.",
+    )
+
+
+class ADOscillatorIndicatorsQueryParams(IndicatorsQueryParams):
+    """Accumulation/Distribution Oscillator Indicators Query Params."""
+
+    fast: int = Field(
+        default=3,
+        description="Number of periods to use for the fast calculation, by default 3.",
+    )
+    slow: int = Field(
+        default=10,
+        description="Number of periods to use for the slow calculation, by default 10.",
+    )
+    offset: int = Field(
+        default=0,
+        description="Offset to be used for the calculation, by default is 0.",
+    )
+
+
+class ADXIndicatorsQueryParams(IndicatorsQueryParams):
+    """Average Directional Index Indicators Query Params."""
+
+    length: int = Field(
+        default=50,
+        description="Window length for the ADX, by default is 50.",
+    )
+    scalar: float = Field(
+        default=100,
+        description="Scalar to multiply the ADX by, default is 100.",
+    )
+    drift: int = Field(
+        default=1,
+        description="Drift value for the ADX, by default is 1.",
+    )
+
+
+class AroonIndicatorsQueryParams(IndicatorsQueryParams):
+    """Aroon Indicators Query Params."""
+
+    length: int = Field(
+        default=25,
+        description="Window length for the Aroon, by default is 50.",
+    )
+    scalar: float = Field(
+        default=100,
+        description="Scalar to multiply the Aroon by, default is 100.",
+    )
+
+
+class ATRIndicatorsQueryParams(IndicatorsQueryParams):
+    """Average True Range Indicators Query Params."""
+
+    length: int = Field(
+        default=14,
+        description="Window length for the ATR, by default is 14.",
+    )
+    mamode: Literal["rma", "ema", "sma", "wma"] = Field(
+        default="rma",
+        description="The mode to use for the moving average calculation.",
+    )
+    drift: int = Field(
+        default=1,
+        description="The difference period.",
+    )
+    offset: int = Field(
+        default=0,
+        description="Number of periods to offset the result, by default is 0.",
+    )
+
+
+class CCIIndicatorsQueryParams(IndicatorsQueryParams):
+    """Commodity Channel Index Indicators Query Params."""
+
+    length: int = Field(
+        default=14,
+        description="Window length for the CCI, by default is 14.",
+    )
+    scalar: float = Field(
+        default=0.015,
+        description="Scalar to multiply the CCI by, default is 0.015.",
+    )
+
+
+class DonchianIndicatorsQueryParams(IndicatorsQueryParams):
+    """Donchian Channel Indicators Query Params."""
+
+    lower: Optional[int] = Field(
+        default=20,
+        description="Window length for the lower band, by default is 20.",
+    )
+    upper: Optional[int] = Field(
+        default=20,
+        description="Window length for the upper band, by default is 20.",
+    )
+    offset: Optional[int] = Field(
+        default=0,
+        description="Number of periods to offset the result, by default is 0.",
+    )
+
+
+class FisherIndicatorsQueryParams(IndicatorsQueryParams):
+    """Fisher Transform Indicators Query Params."""
+
+    length: int = Field(
+        default=14,
+        description="Window length for the Fisher Transform, by default is 14.",
+    )
+    signal: int = Field(
+        default=1,
+        description="Fisher Signal Period",
+    )
+
+
+class KCIndicatorsQueryParams(IndicatorsQueryParams):
+    """Keltner Channel Indicators Query Params."""
+
+    length: int = Field(
+        default=20,
+        description="Window length for the Keltner Channel, by default is 20.",
+    )
+    scalar: float = Field(
+        default=2,
+        description="Scalar to multiply the ATR, by default is 2.",
+    )
+    mamode: MAMODES = Field(
+        default="rma",
+        description="The mode to use for the moving average calculation, by default is ema.",
+    )
+    offset: int = Field(
+        default=0,
+        description="Number of periods to offset the result, by default is 0.",
+    )
+
+
+class MACDIndicatorsQueryParams(IndicatorsQueryParams):
+    """MACD Indicators Query Params."""
+
+    fast: Optional[int] = Field(
+        default=12,
+        description="Window length for the fast EMA, by default is 12.",
+    )
+    slow: Optional[int] = Field(
+        default=26,
+        description="Window length for the slow EMA, by default is 26.",
+    )
+    signal: Optional[int] = Field(
+        default=9,
+        description="Window length for the signal line, by default is 9.",
+    )
+    scalar: Optional[float] = Field(
+        default=100,
+        description="Scalar to multiply the MACD by, default is 100.",
+    )
+
+
+class OBVIndicatorsQueryParams(IndicatorsQueryParams):
+    """On Balance Volume Indicators Query Params."""
+
+    offset: int = Field(
+        default=0,
+        description="Number of periods to offset the result, by default is 0.",
+    )
+
+
+class RSIIndicatorsQueryParams(IndicatorsQueryParams):
+    """RSI Indicators Query Params."""
+
+    length: int = Field(
+        default=14,
+        description="Window length for the RSI, by default is 14.",
+    )
+    scalar: float = Field(
+        default=100,
+        description="Scalar to multiply the RSI by, default is 100.",
+    )
+    drift: int = Field(
+        default=1,
+        description="Drift value for the RSI, by default is 1.",
+    )
+
+
+class StochIndicatorsQueryParams(IndicatorsQueryParams):
+    """Stochastic Oscillator Indicators Query Params."""
+
+    fast_k: int = Field(
+        default=14,
+        description="The fast K period, by default 14.",
+    )
+    slow_d: int = Field(
+        default=3,
+        description="The slow D period, by default 3.",
+    )
+    slow_k: int = Field(
+        default=3,
+        description="The slow K period, by default 3.",
+    )
+
+
+class FibIndicatorsQueryParams(IndicatorsQueryParams):
+    """Fibonacci Retracement Indicators Query Params."""
+
+    period: int = Field(
+        default=120,
+        description="The period to calculate the Fibonacci Retracement, by default 120.",
+    )
+    start_date: Optional[str] = Field(
+        default=None,
+        description="The start date for the Fibonacci Retracement.",
+    )
+    end_date: Optional[str] = Field(
+        default=None,
+        description="The end date for the Fibonacci Retracement.",
+    )
+
+
+class ClenowIndicatorsQueryParams(IndicatorsQueryParams):
+    """Clenow Volatility Adjusted Momentum Indicators Query Params."""
+
+    period: int = Field(
+        default=90,
+        description="The number of periods for the momentum, by default 90.",
+    )
+
+
+class DemarkIndicatorsQueryParams(IndicatorsQueryParams):
+    """Demark Indicators Query Params."""
+
+    show_all: bool = Field(
+        default=False,
+        description="Show 1 - 13. If set to False, show 6 - 9.",
+    )
+    offset: int = Field(
+        default=0,
+        description="Number of periods to offset the result, by default is 0.",
+    )
+
+
+class IchimokuIndicatorsQueryParams(IndicatorsQueryParams):
+    """Ichimoku Cloud Indicators Query Params."""
+
+    conversion: int = Field(
+        default=9,
+        description="The conversion line period, by default 9.",
+    )
+    base: int = Field(
+        default=26,
+        description="The base line period, by default 26.",
+    )
+    lagging: int = Field(
+        default=52,
+        description="The lagging line period, by default 52.",
+    )
+    offset: int = Field(
+        default=26,
+        description="The offset period, by default 26.",
+    )
+    lookahead: bool = Field(
+        default=False,
+        description="Drops the Chikou Span Column to prevent potential data leak",
+    )
+
+
+class SRLinesIndicatorsQueryParams(IndicatorsQueryParams):
+    """Support and Resistance Lines Indicators Query Params."""
+
+    show: bool = Field(
+        default=True,
+        description="Show the support and resistance lines.",
+    )
+
+
+class IndicatorsParams(QueryParams):
+    """Indicators Query Params."""
+
+    sma: SMAIndicatorsQueryParams = Field(
+        default=SMAIndicatorsQueryParams(),
+        description=repr(SMAIndicatorsQueryParams()),
+    )
+    ema: EMAIndicatorsQueryParams = Field(
+        default=EMAIndicatorsQueryParams(),
+        description=repr(EMAIndicatorsQueryParams()),
+    )
+    hma: HMAIndicatorsQueryParams = Field(
+        default=HMAIndicatorsQueryParams(),
+        description=repr(HMAIndicatorsQueryParams()),
+    )
+    wma: WMAIndicatorsQueryParams = Field(
+        default=WMAIndicatorsQueryParams(),
+        description=repr(WMAIndicatorsQueryParams()),
+    )
+    zlma: ZLMAIndicatorsQueryParams = Field(
+        default=ZLMAIndicatorsQueryParams(),
+        description=repr(ZLMAIndicatorsQueryParams()),
+    )
+    ad: ADIndicatorsQueryParams = Field(
+        default=ADIndicatorsQueryParams(),
+        description=repr(ADIndicatorsQueryParams()),
+    )
+    adoscillator: ADOscillatorIndicatorsQueryParams = Field(
+        default=ADOscillatorIndicatorsQueryParams(),
+        description=repr(ADOscillatorIndicatorsQueryParams()),
+    )
+    adx: ADXIndicatorsQueryParams = Field(
+        default=ADXIndicatorsQueryParams(),
+        description=repr(ADXIndicatorsQueryParams()),
+    )
+    aroon: AroonIndicatorsQueryParams = Field(
+        default=AroonIndicatorsQueryParams(),
+        description=repr(AroonIndicatorsQueryParams()),
+    )
+    atr: ATRIndicatorsQueryParams = Field(
+        default=ATRIndicatorsQueryParams(),
+        description=repr(ATRIndicatorsQueryParams()),
+    )
+    cci: CCIIndicatorsQueryParams = Field(
+        default=CCIIndicatorsQueryParams(),
+        description=repr(CCIIndicatorsQueryParams()),
+    )
+    clenow: ClenowIndicatorsQueryParams = Field(
+        default=ClenowIndicatorsQueryParams(),
+        description=repr(ClenowIndicatorsQueryParams()),
+    )
+    demark: DemarkIndicatorsQueryParams = Field(
+        default=DemarkIndicatorsQueryParams(),
+        description=repr(DemarkIndicatorsQueryParams()),
+    )
+    donchian: DonchianIndicatorsQueryParams = Field(
+        default=DonchianIndicatorsQueryParams(),
+        description=repr(DonchianIndicatorsQueryParams()),
+    )
+    fib: FibIndicatorsQueryParams = Field(
+        default=FibIndicatorsQueryParams(),
+        description=repr(FibIndicatorsQueryParams()),
+    )
+    fisher: FisherIndicatorsQueryParams = Field(
+        default=FisherIndicatorsQueryParams(),
+        description=repr(FisherIndicatorsQueryParams()),
+    )
+    ichimoku: IchimokuIndicatorsQueryParams = Field(
+        default=IchimokuIndicatorsQueryParams(),
+        description=repr(IchimokuIndicatorsQueryParams()),
+    )
+    kc: KCIndicatorsQueryParams = Field(
+        default=KCIndicatorsQueryParams(),
+        description=repr(KCIndicatorsQueryParams()),
+    )
+    macd: MACDIndicatorsQueryParams = Field(
+        default=MACDIndicatorsQueryParams(),
+        description=repr(MACDIndicatorsQueryParams()),
+    )
+    obv: OBVIndicatorsQueryParams = Field(
+        default=OBVIndicatorsQueryParams(),
+        description=repr(OBVIndicatorsQueryParams()),
+    )
+    rsi: RSIIndicatorsQueryParams = Field(
+        default=RSIIndicatorsQueryParams(),
+        description=repr(RSIIndicatorsQueryParams()),
+    )
+    srlines: SRLinesIndicatorsQueryParams = Field(
+        default=SRLinesIndicatorsQueryParams(),
+        description=repr(SRLinesIndicatorsQueryParams()),
+    )
+    stoch: StochIndicatorsQueryParams = Field(
+        default=StochIndicatorsQueryParams(),
+        description=repr(StochIndicatorsQueryParams()),
+    )
+
+    def __repr__(self):
+        """Return the string representation of the model."""
+        fields = self.__class__.model_fields
+        repr_str = "\n" + "\n".join(
+            [
+                f"{str(v.description).replace('IndicatorsQueryParams', ':').replace('ADOs', 'AD Os')}"
+                for k, v in fields.items()
+            ]
+        )
+        return repr_str
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_model(cls, values):
+        """Validate the model."""
+        indicators = list(ChartIndicators.get_available_indicators())
+        for k, v in values.items():
+            if k not in indicators:
+                raise ValueError(f"{k} is not a valid indicator.")
+        return values

openbb_platform/obbject_extensions/charting/openbb_charting/styles/__init__.py

@@ -0,0 +1 @@
+"""Charting Extension Styles"""

openbb_platform/obbject_extensions/charting/openbb_charting/styles/colors.py

@@ -0,0 +1,39 @@
+"""Color Palettes and Sequences for OpenBB Charting"""
+
+LARGE_CYCLER = [
+    "#1f77b4",
+    "#7f7f7f",
+    "#ff7f0e",
+    "#2ca02c",
+    "#d62728",
+    "#9467bd",
+    "#8c564b",
+    "#e377c2",
+    "#bcbd22",
+    "#17becf",
+    "burlywood",
+    "magenta",
+    "cyan",
+    "yellowgreen",
+    "#aec7e8",
+    "#ffbb78",
+    "#ff9896",
+    "#c5b0d5",
+    "#c49c94",
+    "#f7b6d2",
+    "#c7c7c7",
+    "#dbdb8d",
+    "#9edae5",
+    "#7e7e7e",
+    "#1b9e77",
+    "#d95f02",
+    "#7570b3",
+    "#e7298a",
+    "#66a61e",
+    "#e6ab02",
+    "#a6761d",
+    "#666666",
+    "#f0027f",
+    "#bf5b17",
+    "#d9f202",
+]

openbb_platform/obbject_extensions/charting/openbb_charting/styles/default/dark.pltstyle.json

@@ -0,0 +1,143 @@
+{
+    "line": {
+        "up_color": "#00ACFF",
+        "down_color": "#e4003a",
+        "color": "#ffed00",
+        "width": 1.5
+    },
+    "data": {
+        "candlestick": [
+            {
+                "decreasing": {
+                    "fillcolor": "#e4003a",
+                    "line": {
+                        "color": "#e4003a"
+                    }
+                },
+                "increasing": {
+                    "fillcolor": "#00ACFF",
+                    "line": {
+                        "color": "#00ACFF"
+                    }
+                },
+                "type": "candlestick"
+            }
+        ]
+    },
+    "layout": {
+        "annotationdefaults": {
+            "showarrow": false
+        },
+        "autotypenumbers": "strict",
+        "colorway": [
+            "#1f77b4",
+            "#ff7f0e",
+            "#2ca02c",
+            "#d62728",
+            "#9467bd",
+            "#8c564b",
+            "#e377c2",
+            "#bcbd22",
+            "#17becf",
+            "#aec7e8",
+            "#ffbb78",
+            "#ff9896",
+            "#c5b0d5",
+            "#f7b6d2",
+            "#dbdb8d",
+            "#9edae5"
+        ],
+        "dragmode": "pan",
+        "font": {
+            "family": "Arial",
+            "size": 18
+        },
+        "hoverlabel": {
+            "align": "left"
+        },
+        "mapbox": {
+            "style": "dark"
+        },
+        "hovermode": "x",
+        "legend": {
+            "bgcolor": "rgba(0, 0, 0, 0)",
+            "x": 1,
+            "xanchor": "right",
+            "y": 1.02,
+            "yanchor": "bottom",
+            "font": {
+                "size": 12
+            }
+        },
+        "legend2": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend3": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend4": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend5": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "paper_bgcolor": "#000000",
+        "plot_bgcolor": "#000000",
+        "xaxis": {
+            "automargin": true,
+            "autorange": true,
+            "rangeslider": {
+                "visible": false
+            },
+            "showgrid": true,
+            "showline": true,
+            "tickfont": {
+                "size": 14
+            },
+            "zeroline": false,
+            "tick0": 1,
+            "title": {
+                "standoff": 20,
+                "font": {
+                    "size": 16
+                }
+            },
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        },
+        "yaxis": {
+            "anchor": "x",
+            "automargin": true,
+            "fixedrange": false,
+            "zeroline": false,
+            "showgrid": true,
+            "showline": true,
+            "side": "right",
+            "tick0": 0.5,
+            "title": {
+                "standoff": 20,
+                "font": {
+                    "size": 16
+                }
+            },
+
+            "gridcolor": "rgba(128, 128, 128, 0.33)",
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        }
+    }
+}

openbb_platform/obbject_extensions/charting/openbb_charting/styles/default/light.pltstyle.json

@@ -0,0 +1,142 @@
+{
+    "line": {
+        "up_color": "#0074D9",
+        "down_color": "#FF4136",
+        "color": "#111111",
+        "width": 1.5
+    },
+    "data": {
+        "candlestick": [
+            {
+                "decreasing": {
+                    "fillcolor": "#e4003a",
+                    "line": {
+                        "color": "#e4003a"
+                    }
+                },
+                "increasing": {
+                    "fillcolor": "#00ACFF",
+                    "line": {
+                        "color": "#00ACFF"
+                    }
+                },
+                "type": "candlestick"
+            }
+        ]
+    },
+    "layout": {
+        "annotationdefaults": {
+            "showarrow": false
+        },
+        "autotypenumbers": "strict",
+        "colorway": [
+            "#1f77b4",
+            "#ff7f0e",
+            "#2ca02c",
+            "#d62728",
+            "#9467bd",
+            "#8c564b",
+            "#e377c2",
+            "#bcbd22",
+            "#17becf",
+            "#aec7e8",
+            "#ffbb78",
+            "#ff9896",
+            "#c5b0d5",
+            "#f7b6d2",
+            "#dbdb8d",
+            "#9edae5"
+        ],
+        "dragmode": "pan",
+        "font": {
+            "family": "Arial",
+            "size": 18
+        },
+        "hoverlabel": {
+            "align": "left"
+        },
+        "mapbox": {
+            "style": "light"
+        },
+        "hovermode": "x",
+        "legend": {
+            "bgcolor": "rgba(255, 255, 255, 0)",
+            "x": 1,
+            "xanchor": "right",
+            "y": 1.02,
+            "yanchor": "bottom",
+            "font": {
+                "size": 12
+            }
+        },
+        "legend2": {
+            "bgcolor": "rgba(255, 255, 255, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend3": {
+            "bgcolor": "rgba(255, 255, 255, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend4": {
+            "bgcolor": "rgba(255, 255, 255, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend5": {
+            "bgcolor": "rgba(255, 255, 255, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "paper_bgcolor": "#FFFFFF",
+        "plot_bgcolor": "#FFFFFF",
+        "xaxis": {
+            "automargin": true,
+            "autorange": true,
+            "rangeslider": {
+                "visible": false
+            },
+            "showgrid": true,
+            "showline": true,
+            "tickfont": {
+                "size": 14
+            },
+            "zeroline": false,
+            "tick0": 1,
+            "title": {
+                "standoff": 20,
+                "font": {
+                    "size": 16
+                }
+            },
+            "linecolor": "#A9A9A9",
+            "mirror": true,
+            "ticks": "outside"
+        },
+        "yaxis": {
+            "anchor": "x",
+            "automargin": true,
+            "fixedrange": false,
+            "zeroline": false,
+            "showgrid": true,
+            "showline": true,
+            "side": "right",
+            "tick0": 0.5,
+            "title": {
+                "standoff": 20,
+                "font": {
+                    "size": 16
+                }
+            },
+            "gridcolor": "rgba(128, 128, 128, 0.33)",
+            "linecolor": "#A9A9A9",
+            "mirror": true,
+            "ticks": "outside"
+        }
+    }
+}

openbb_platform/obbject_extensions/charting/openbb_charting/styles/default/tables.pltstyle.json

@@ -0,0 +1,102 @@
+{
+    "data": {
+        "candlestick": [
+            {
+                "decreasing": {
+                    "fillcolor": "#e4003a",
+                    "line": {
+                        "color": "#e4003a"
+                    }
+                },
+                "increasing": {
+                    "fillcolor": "#00ACFF",
+                    "line": {
+                        "color": "#00ACFF"
+                    }
+                },
+                "type": "candlestick"
+            }
+        ]
+    },
+    "layout": {
+        "annotationdefaults": {
+            "showarrow": false
+        },
+        "autotypenumbers": "strict",
+        "colorway": [
+            "#ffed00",
+            "#ef7d00",
+            "#e4003a",
+            "#c13246",
+            "#822661",
+            "#48277c",
+            "#005ca9",
+            "#00aaff",
+            "#9b30d9",
+            "#af005f",
+            "#5f00af",
+            "#af87ff"
+        ],
+        "dragmode": "pan",
+        "font": {
+            "family": "Fira Code",
+            "size": 18
+        },
+        "hoverlabel": {
+            "align": "left"
+        },
+        "mapbox": {
+            "style": "light"
+        },
+        "hovermode": "x",
+        "legend": {
+            "bgcolor": "rgba(0, 0, 0, 0)",
+            "x": 0.01,
+            "xanchor": "left",
+            "y": 0.99,
+            "yanchor": "top",
+            "font": {
+                "size": 15
+            }
+        },
+        "paper_bgcolor": "white",
+        "plot_bgcolor": "white",
+        "xaxis": {
+            "automargin": true,
+            "autorange": true,
+            "rangeslider": {
+                "visible": false
+            },
+            "showgrid": true,
+            "showline": true,
+            "tickfont": {
+                "size": 14
+            },
+            "zeroline": false,
+            "tick0": 1,
+            "title": {
+                "standoff": 20
+            },
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        },
+        "yaxis": {
+            "anchor": "x",
+            "automargin": true,
+            "fixedrange": false,
+            "zeroline": false,
+            "showgrid": true,
+            "showline": true,
+            "side": "right",
+            "tick0": 0.5,
+            "title": {
+                "standoff": 20
+            },
+            "gridcolor": "#283442",
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        }
+    }
+}

openbb_platform/obbject_extensions/charting/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "openbb-charting"
+version = "2.3.4"
+description = "Charting extension for OpenBB"
+authors = ["OpenBB Team <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+packages = [{ include = "openbb_charting" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9.21,<3.13"  # scipy forces python <4.0 explicitly
+openbb-core = "^1.4.7"
+pandas-ta-openbb = "^0.4.20"
+plotly = "^6.1.1"
+pywry = { version = "^0.6.2", optional = true }
+nbformat = "^5.10.0"
+
+[tool.poetry.extras]
+pywry = ["pywry"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."openbb_obbject_extension"]
+openbb_charting = "openbb_charting:ext"

openbb_platform/obbject_extensions/charting/tests/__init__.py

@@ -0,0 +1 @@
+"""OBBject Extensions Charting Tests Module."""