path: root/openbb_terminal/core/plots/plotly_ta/ta_class.py

# pylint: disable=R0902
import importlib
import inspect
import sys
from pathlib import Path
from typing import Any, Dict, List, Optional, Type, Union

import pandas as pd

from openbb_terminal import OpenBBFigure, config_terminal, theme
from openbb_terminal.common.technical_analysis import ta_helpers
from openbb_terminal.core.config.paths import REPOSITORY_DIRECTORY
from openbb_terminal.core.plots.plotly_ta.base import PltTA
from openbb_terminal.core.plots.plotly_ta.data_classes import ChartIndicators
from openbb_terminal.core.session.current_system import get_current_system
from openbb_terminal.rich_config import console

PLUGINS_PATH = Path(__file__).parent / "plugins"
PLOTLY_TA: Optional["PlotlyTA"] = None


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_terminal.sdk import openbb
    >>> from openbb_terminal.core.plots.plotly_ta.ta_class import PlotlyTA

    >>> df = openbb.stocks.load("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 = openbb.stocks.load("AAPL")
    >>> fig2 = ta.plot(df2)
    >>> fig.show()
    >>> fig2.show()
    """

    inchart_colors = theme.get_colors()
    plugins: List[Type[PltTA]] = []
    df_ta: pd.DataFrame = None
    close_column: Optional[str] = "Close"
    has_volume: bool = True
    show_volume: bool = True

    def __new__(cls, *args, **kwargs):
        """This method is overridden to create a singleton instance of the class."""
        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)
            PLOTLY_TA._locate_plugins()
            PLOTLY_TA.add_plugins(PLOTLY_TA.plugins)

        cls.inchart_colors = theme.get_colors()
        return PLOTLY_TA

    def __init__(self, *args, **kwargs):  # pylint: disable=unused-argument
        """This 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
            super().__init__(*args, **kwargs)

    @property
    def ma_mode(self) -> List[str]:
        return list(set(self.__ma_mode__))

    @ma_mode.setter
    def ma_mode(self, value: List[str]):
        self.__ma_mode__ = value

    @property
    def inchart(self) -> List[str]:
        return list(set(self.__inchart__))

    @inchart.setter
    def inchart(self, value: List[str]):
        self.__inchart__ = value

    @property
    def subplots(self) -> List[str]:
        return list(set(self.__subplots__))

    @subplots.setter
    def subplots(self, value: List[str]):
        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,
        fig: Optional[OpenBBFigure] = None,
        volume_ticks_x: int = 7,
    ) -> OpenBBFigure:
        """This method should not be called directly. Use the PlotlyTA.plot() static method instead."""

        if config_terminal.HOLD:
            console.print(
                "The previous command is not supported within hold on.  Only the last command run"
                "will be displayed when hold off is run."
            )

        if isinstance(df_stock, pd.Series):
            df_stock = df_stock.to_frame()

        if not isinstance(indicators, ChartIndicators):
            indicators = ChartIndicators.from_dict(indicators or {})

        self.indicators = indicators
        self.intraday = df_stock.index[-2].time() != df_stock.index[-1].time()
        self.df_stock = df_stock
        self.close_column = ta_helpers.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

        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,
        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
        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 Pl