openbb-charting 2.0.0__tar.gz → 2.0.2__tar.gz

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openbb-charting
-Version: 2.0.0
+Version: 2.0.2
 Summary: Charting extension for OpenBB
 Author: OpenBB Team
 Author-email: hello@openbb.co
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: nbformat (>=5.9.2,<6.0.0)
-Requires-Dist: openbb-core (>=1.1.2,<2.0.0)
+Requires-Dist: openbb-core (>=1.1.5,<2.0.0)
 Requires-Dist: pandas-ta (>=0.3.14b,<0.4.0)
 Requires-Dist: plotly (>=5.17.0,<6.0.0)
 Requires-Dist: pywry (>=0.6.1,<0.7.0)

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/openbb_charting/__init__.py

@@ -6,7 +6,6 @@ from typing import (
     Dict,
     List,
     Optional,
-    Tuple,
     Union,
 )
 
@@ -18,7 +17,7 @@ from openbb_core.app.utils import basemodel_to_df, convert_to_basemodel
 from openbb_core.provider.abstract.data import Data
 
 from openbb_charting import charting_router
-from openbb_charting.core.to_chart import ChartIndicators, OpenBBFigure, to_chart
+from openbb_charting.core.to_chart import ChartIndicators, to_chart
 from openbb_charting.utils.helpers import get_charting_functions
 
 ext = Extension(name="charting")
@@ -49,8 +48,8 @@ class Charting:
 
         self._obbject: OBBject = obbject
         self._charting_settings = ChartingSettings(
-            user_settings=self._obbject._user_settings,
-            system_settings=self._obbject._system_settings,
+            user_settings=self._obbject._user_settings,  # type: ignore
+            system_settings=self._obbject._system_settings,  # type: ignore
         )
         self._handle_backend()
 
@@ -91,7 +90,9 @@ class Charting:
             kwargs["standard_params"] = (
                 self._obbject._standard_params.__dict__  # pylint: disable=protected-access
             )
-
+        kwargs["provider"] = self._obbject.provider  # pylint: disable=protected-access
+        kwargs["extra"] = self._obbject.extra  # pylint: disable=protected-access
+        kwargs["warnings"] = self._obbject.warnings  # pylint: disable=protected-access
         fig, content = charting_function(**kwargs)
         self._obbject.chart = Chart(
             fig=fig, content=content, format=charting_router.CHART_FORMAT
@@ -178,24 +179,36 @@ class Charting:
         index = (
             data.index.name
             if has_data and isinstance(data, (pd.DataFrame, pd.Series))
-            else ""
+            else None
         )
         data_as_df: pd.DataFrame = (
             basemodel_to_df(convert_to_basemodel(data), index=index)
             if has_data
             else self._obbject.to_dataframe()
         )
-        fig, content = to_chart(
-            data_as_df,
-            indicators=indicators,
-            symbol=symbol,
-            candles=candles,
-            volume=volume,
-            prepost=prepost,
-            volume_ticks_x=volume_ticks_x,
-        )
-        self._obbject.chart = Chart(
-            fig=fig, content=content, format=charting_router.CHART_FORMAT
-        )
-        if render:
-            fig.show(**kwargs)
+        if "date" in data_as_df.columns:
+            data_as_df = data_as_df.set_index("date")
+        try:
+            fig, content = to_chart(
+                data_as_df,
+                indicators=indicators,
+                symbol=symbol,
+                candles=candles,
+                volume=volume,
+                prepost=prepost,
+                volume_ticks_x=volume_ticks_x,
+            )
+            self._obbject.chart = Chart(
+                fig=fig, content=content, format=charting_router.CHART_FORMAT
+            )
+            if render:
+                fig.show(**kwargs)
+
+        except Exception:
+            try:
+                if has_data:
+                    self.show(data=data_as_df, symbol=symbol, render=render, **kwargs)
+                else:
+                    self.show(**kwargs)
+            except Exception as e:
+                raise RuntimeError("Could not create chart from the OBBject.") from e

openbb_charting-2.0.2/openbb_charting/charting_router.py

@@ -0,0 +1,538 @@
+"""Charting router."""
+
+import json
+from typing import Any, Dict, Optional, Tuple, Union
+
+import pandas as pd
+from openbb_core.app.model.charts.chart import ChartFormat
+from openbb_core.app.utils import basemodel_to_df
+
+from openbb_charting.core.chart_style import ChartStyle
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_charting.core.plotly_ta.ta_class import PlotlyTA
+from openbb_charting.query_params import (
+    FredSeriesChartQueryParams,
+    TechnicalConesChartQueryParams,
+)
+
+CHART_FORMAT = ChartFormat.plotly
+
+# if TYPE_CHECKING:
+
+# from .core.openbb_figure_table import OpenBBFigureTable
+
+
+def equity_price_historical(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Equity price chart."""
+
+    def handle_indicators(ma):
+        """Handle indicators."""
+        k = {}
+        if ma:
+            k["rma"] = dict(length=ma)
+        return k
+
+    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
+    standard_params = kwargs["standard_params"]
+    ma = standard_params.get("ma", None)
+    prepost = standard_params.get("prepost", False)
+    symbol = standard_params.get("symbol", "")
+
+    ta = PlotlyTA()
+    fig = ta.plot(
+        data,
+        indicators=dict(**handle_indicators(ma)),
+        symbol=f"{symbol} historical data",
+        prepost=prepost,
+    )
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content
+
+
+def _ta_ma(ma_type: str, **kwargs):
+    """Plot moving average helper."""
+    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
+    window = kwargs.get("window", 50)
+    offset = kwargs.get("offset", 0)
+    symbol = kwargs.get("symbol", "")
+
+    ta = PlotlyTA()
+    fig = ta.plot(
+        data,
+        {f"{ma_type.lower()}": dict(length=window, offset=offset)},
+        f"{symbol.upper()} {ma_type.upper()}",
+        False,
+        volume=False,
+    )
+    fig.update_layout(ChartStyle().plotly_template.get("layout", {}))
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content
+
+
+def technical_zlma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Zero lag moving average chart."""
+    ma_type = "zlma"
+    return _ta_ma(ma_type, **kwargs)
+
+
+def technical_aroon(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Aroon chart."""
+    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
+    length = kwargs.get("length", 25)
+    scalar = kwargs.get("scalar", 100)
+    symbol = kwargs.get("symbol", "")
+
+    ta = PlotlyTA()
+    fig = ta.plot(
+        data,
+        dict(aroon=dict(length=length, scalar=scalar)),
+        f"Aroon on {symbol}",
+        False,
+        volume=False,
+    )
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content
+
+
+def technical_sma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Plot simple moving average chart."""
+    ma_type = "sma"
+    return _ta_ma(ma_type, **kwargs)
+
+
+def technical_macd(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Plot moving average convergence divergence chart."""
+    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
+    fast = kwargs.get("fast", 12)
+    slow = kwargs.get("slow", 26)
+    signal = kwargs.get("signal", 9)
+    symbol = kwargs.get("symbol", "")
+
+    ta = PlotlyTA()
+    fig = ta.plot(
+        data,
+        dict(macd=dict(fast=fast, slow=slow, signal=signal)),
+        f"{symbol.upper()} MACD",
+        False,
+        volume=False,
+    )
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content
+
+
+def technical_hma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Hull moving average chart."""
+    ma_type = "hma"
+    return _ta_ma(ma_type, **kwargs)
+
+
+def technical_adx(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Average directional movement index chart."""
+    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
+    length = kwargs.get("length", 14)
+    scalar = kwargs.get("scalar", 100.0)
+    drift = kwargs.get("drift", 1)
+    symbol = kwargs.get("symbol", "")
+
+    ta = PlotlyTA()
+    fig = ta.plot(
+        data,
+        dict(adx=dict(length=length, scalar=scalar, drift=drift)),
+        f"Average Directional Movement Index (ADX) {symbol}",
+        False,
+        volume=False,
+    )
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content
+
+
+def technical_wma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Weighted moving average chart."""
+    ma_type = "wma"
+    return _ta_ma(ma_type, **kwargs)
+
+
+def technical_rsi(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Relative strength index chart."""
+    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
+    window = kwargs.get("window", 14)
+    scalar = kwargs.get("scalar", 100.0)
+    drift = kwargs.get("drift", 1)
+    symbol = kwargs.get("symbol", "")
+
+    ta = PlotlyTA()
+    fig = ta.plot(
+        data,
+        dict(rsi=dict(length=window, scalar=scalar, drift=drift)),
+        f"{symbol.upper()} RSI {window}",
+        False,
+        volume=False,
+    )
+    content = fig.show(external=True).to_plotly_json()
+
+    return fig, content
+
+
+def technical_ema(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Exponential moving average chart."""
+    ma_type = "ema"
+    return _ta_ma(ma_type, **kwargs)
+
+
+def technical_cones(
+    **kwargs: TechnicalConesChartQueryParams,
+) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """Volatility Cones Chart."""
+    data = kwargs.get("data")
+
+    if isinstance(data, pd.DataFrame) and not data.empty and "window" in data.columns:
+        df_ta = data.set_index("window")
+    else:
+        df_ta = basemodel_to_df(kwargs["obbject_item"], index="window")  # type: ignore
+
+    df_ta.columns = [col.title().replace("_", " ") for col in df_ta.columns]
+
+    # Check if the data is formatted as expected.
+    if not all(col in df_ta.columns for col in ["Realized", "Min", "Median", "Max"]):
+        raise ValueError("Data supplied does not match the expected format.")
+
+    model = (
+        str(kwargs.get("model"))
+        .replace("std", "Standard Deviation")
+        .replace("_", "-")
+        .title()
+        if kwargs.get("model")
+        else "Standard Deviation"
+    )
+
+    symbol = str(kwargs.get("symbol")) + " - " if kwargs.get("symbol") else ""
+
+    title = (
+        str(kwargs.get("title"))
+        if kwargs.get("title")
+        else f"{symbol}Realized Volatility Cones - {model} Model"
+    )
+
+    colors = [
+        "green",
+        "red",
+        "burlywood",
+        "grey",
+        "orange",
+        "blue",
+    ]
+    color = 0
+
+    fig = OpenBBFigure()
+
+    fig.update_layout(ChartStyle().plotly_template.get("layout", {}))
+
+    text_color = "black" if ChartStyle().plt_style == "light" else "white"
+
+    for col in df_ta.columns:
+        fig.add_scatter(
+            x=df_ta.index,
+            y=df_ta[col],
+            name=col,
+            mode="lines+markers",
+            hovertemplate=f"{col}: %{{y}}<extra></extra>",
+            marker=dict(
+                color=colors[color],
+                size=11,
+            ),
+        )
+        color += 1
+
+    fig.set_title(title)
+
+    fig.update_layout(
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font=dict(color=text_color),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            xanchor="right",
+            y=1.02,
+            x=1,
+            bgcolor="rgba(0,0,0,0)",
+        ),
+        yaxis=dict(
+            ticklen=0,
+        ),
+        xaxis=dict(
+            type="category",
+            tickmode="array",
+            ticklen=0,
+            tickvals=df_ta.index,
+            ticktext=df_ta.index,
+            title_text="Period",
+            showgrid=False,
+            zeroline=False,
+        ),
+        margin=dict(l=20, r=20, b=20),
+        dragmode="pan",
+    )
+
+    content = fig.to_plotly_json()
+
+    return fig, content
+
+
+def economy_fred_series(
+    **kwargs: Union[Any, FredSeriesChartQueryParams],
+) -> Tuple["OpenBBFigure", Dict[str, Any]]:
+    """FRED Series Chart."""
+    ytitle_dict = {
+        "chg": "Change",
+        "ch1": "Change From Year Ago",
+        "pch": "Percent Change",
+        "pc1": "Percent Change From Year Ago",
+        "pca": "Compounded Annual Rate Of Change",
+        "cch": "Continuously Compounded Rate Of Change",
+        "cca": "Continuously Compounded Annual Rate Of Change",
+        "log": "Natural Log",
+    }
+
+    colors = [
+        "#1f77b4",
+        "#7f7f7f",
+        "#ff7f0e",
+        "#2ca02c",
+        "#d62728",
+        "#9467bd",
+        "#8c564b",
+        "#e377c2",
+        "#7f7f7f",
+        "#bcbd22",
+        "#17becf",
+    ]
+
+    provider = kwargs.get("provider")
+
+    if provider != "fred":
+        raise RuntimeError(
+            f"This charting method does not support {provider}. Supported providers: fred."
+        )
+
+    columns = basemodel_to_df(kwargs["obbject_item"], index=None).columns.to_list()  # type: ignore
+
+    allow_unsafe = kwargs.get("allow_unsafe", False)
+    dropnan = kwargs.get("dropna", True)
+    normalize = kwargs.get("normalize", False)
+
+    data_cols = []
+    data = kwargs.get("data")
+
+    if isinstance(data, pd.DataFrame) and not data.empty:
+        data_cols = data.columns.to_list()
+        df_ta = data
+
+    else:
+        df_ta = basemodel_to_df(kwargs["obbject_item"], index="date")  # type: ignore
+
+    # Check for unsupported external data injection.
+    if allow_unsafe is False and data_cols:
+        for data_col in data_cols:
+            if data_col not in columns:
+                raise RuntimeError(
+                    f"Column '{data_col}' was not found in the original data."
+                    + " External data injection is not supported unless `allow_unsafe = True`."
+                )
+
+    # Align the data so each column has the same index and length.
+    if dropnan:
+        df_ta = df_ta.dropna(how="any")
+
+    if df_ta.empty or len(df_ta) < 2:
+        raise ValueError(
+            "No data is left after dropping NaN values. Try setting `dropnan = False`,"
+            + " or use the `frequency` parameter on request ."
+        )
+
+    columns = df_ta.columns.to_list()
+
+    def z_score_standardization(data: pd.Series) -> pd.Series:
+        """Z-Score Standardization Method."""
+        return (data - data.mean()) / data.std()
+
+    if normalize:
+        df_ta = df_ta.apply(z_score_standardization)
+
+    # Extract the metadata from the warnings.
+    warnings = kwargs.get("warnings")
+    metadata = json.loads(warnings[0].message) if warnings else {}  # type: ignore
+
+    # Check if the request was transformed by the FRED API.
+    params = kwargs["extra_params"] if kwargs.get("extra_params") else {}
+    has_params = hasattr(params, "transform") and params.transform is not None  # type: ignore
+
+    # Get a unique list of all units of measurement in the DataFrame.
+    y_units = list({metadata.get(col).get("units") for col in columns if col in metadata})  # type: ignore
+
+    if len(y_units) > 2 and has_params is False and allow_unsafe is True:
+        raise RuntimeError(
+            "This method supports up to 2 y-axis units."
+            + " Please use the 'transform' parameter, in the data request,"
+            + " to compare all series on the same scale, or set `normalize = True`."
+            + " Override this error by setting `allow_unsafe = True`."
+        )
+
+    y1_units = y_units[0] if y_units else None
+    y1title = y1_units
+    y2title = y_units[1] if len(y_units) > 1 else None
+    xtitle = ""
+
+    # If the request was transformed, the y-axis will be shared under these conditions.
+    if has_params and any(
+        i in params.transform for i in ["pc1", "pch", "pca", "cch", "cca", "log"]  # type: ignore
+    ):
+        y1title = "Log" if params.transform == "Log" else "Percent"  # type: ignore
+        y2title = None
+
+    # Set the title for the chart.
+    title: str = ""
+    if isinstance(kwargs, dict) and title in kwargs:
+        title = kwargs["title"]
+    else:
+        if metadata.get(columns[0]):
+            title = metadata.get(columns[0]).get("title") if len(columns) == 1 else "FRED Series"  # type: ignore
+        else:
+            title = "FRED Series"
+        transform_title = ytitle_dict.get(params.transform) if has_params is True else ""  # type: ignore
+        title = f"{title} - {transform_title}" if transform_title else title
+
+    # Define this to use as a check.
+    y3title: Optional[str] = ""
+
+    # Create the figure object with subplots.
+    fig = OpenBBFigure().create_subplots(
+        rows=1, cols=1, shared_xaxes=True, shared_yaxes=False
+    )
+    fig.update_layout(ChartStyle().plotly_template.get("layout", {}))
+    text_color = "black" if ChartStyle().plt_style == "light" else "white"
+
+    # For each series in the DataFrame, add a scatter plot.
+    for i, col in enumerate(df_ta.columns):
+
+        # Check if the y-axis should be shared for this series.
+        on_y1 = (
+            (
+                metadata.get(col).get("units") == y1_units
+                or y2title is None  # type: ignore
+            )
+            if metadata.get(col)
+            else False
+        )
+        if normalize:
+            on_y1 = True
+        yaxes = "y2" if not on_y1 else "y1"
+        on_y3 = not metadata.get(col) and normalize is False
+        if on_y3:
+            yaxes = "y3"
+            y3title = df_ta[col].name
+        fig.add_scatter(
+            x=df_ta.index,
+            y=df_ta[col],
+            name=df_ta[col].name,
+            mode="lines",
+            hovertemplate=f"{df_ta[col].name}: %{{y}}<extra></extra>",
+            line=dict(width=1, color=colors[i % len(colors)]),
+            yaxis=yaxes,
+        )
+
+    # Set the y-axis titles, if supplied.
+    if kwargs.get("y1title"):
+        y1title = kwargs.get("y1title")
+    if kwargs.get("y2title") and y2title is not None:
+        y2title = kwargs.get("y2title")
+    # Set the x-axis title, if suppiled.
+    if isinstance(kwargs, dict) and "xtitle" in kwargs:
+        xtitle = kwargs["xtitle"]
+    # If the data was normalized, set the title to reflect this.
+    if normalize:
+        y1title = None
+        y2title = None
+        y3title = None
+        title = f"{title} - Normalized" if title else "Normalized"
+
+    # Now update the layout of the complete figure.
+    fig.update_layout(
+        title=dict(text=title, x=0.5, font=dict(size=16)),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font=dict(color=text_color),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            xanchor="right",
+            y=1.02,
+            x=1,
+            bgcolor="rgba(0,0,0,0)",
+        ),
+        yaxis=(
+            dict(
+                ticklen=0,
+                side="right",
+                title=dict(text=y1title, standoff=30, font=dict(size=18)),
+                tickfont=dict(size=14),
+                anchor="x",
+            )
+            if y1title
+            else None
+        ),
+        yaxis2=(
+            dict(
+                overlaying="y",
+                side="left",
+                ticklen=0,
+                showgrid=False,
+                title=dict(
+                    text=y2title if y2title else None, standoff=10, font=dict(size=18)
+                ),
+                tickfont=dict(size=14),
+                anchor="x",
+            )
+            if y2title
+            else None
+        ),
+        yaxis3=(
+            dict(
+                overlaying="y",
+                side="left",
+                ticklen=0,
+                position=0,
+                showgrid=False,
+                showticklabels=True,
+                title=(
+                    dict(text=y3title, standoff=10, font=dict(size=16))
+                    if y3title
+                    else None
+                ),
+                tickfont=dict(size=12, color="rgba(128,128,128,0.75)"),
+                anchor="free",
+            )
+            if y3title
+            else None
+        ),
+        xaxis=dict(
+            ticklen=0,
+            showgrid=False,
+            title=(
+                dict(text=xtitle, standoff=30, font=dict(size=18)) if xtitle else None
+            ),
+            domain=[0.095, 0.95] if y3title else None,
+        ),
+        margin=dict(r=25, l=25) if normalize is False else None,
+        autosize=True,
+        dragmode="pan",
+    )
+
+    content = fig.to_plotly_json()
+
+    return fig, content

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/openbb_charting/core/backend.py

@@ -152,7 +152,6 @@ class Backend(PyWry):
         theme: Optional[str] = None,
     ) -> dict:
         """Get the json update for the backend."""
-
         posthog: Dict[str, Any] = dict(collect_logs=self.charting_settings.log_collect)
         if (
             self.charting_settings.log_collect
@@ -222,6 +221,11 @@ class Backend(PyWry):
         self.send_outgoing(outgoing)
 
         if export_image and isinstance(export_image, Path):
+            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):
@@ -507,6 +511,7 @@ if not PLOTLYJS_PATH.exists() and not JUPYTER_NOTEBOOK:
 
 
 def create_backend(charting_settings: Optional["ChartingSettings"] = None):
+    """Create the backend."""
     # # pylint: disable=import-outside-toplevel
     from openbb_core.app.model.charts.charting_settings import ChartingSettings
 
@@ -517,6 +522,7 @@ def create_backend(charting_settings: Optional["ChartingSettings"] = None):
 
 
 def get_backend() -> Backend:
+    """Get the backend instance."""
     if BACKEND is None:
         raise ValueError("Backend not created")
     return BACKEND

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/openbb_charting/core/openbb_figure.py

@@ -923,11 +923,7 @@ class OpenBBFigure(go.Figure):
                 # If the backend fails, we just show the figure normally
                 # This is a very rare case, but it's better to have a fallback
 
-                if getattr(self._charting_settings, "debug_mode", False):
-                    warn(f"Failed to show figure with backend: {e}")
-                warn(
-                    f"Failed to show figure with backend: {e}"
-                )  # remove this line when the above lines are figured out
+                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

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/openbb_charting/core/plotly_ta/base.py

@@ -1,4 +1,6 @@
-from typing import Any, Callable, Dict, Iterator, List, Optional, Type
+"""Base class for charting plugins."""
+
+from typing import Any, Callable, Dict, Iterator, List, Optional, Type, Union
 
 import pandas as pd
 
@@ -6,7 +8,7 @@ from .data_classes import ChartIndicators, TAIndicator
 
 
 def columns_regex(df_ta: pd.DataFrame, name: str) -> List[str]:
-    """Return columns that match regex name"""
+    """Return columns that match regex name."""
     column_name = df_ta.filter(regex=rf"{name}(?=[^\d]|$)").columns.tolist()
 
     return column_name
@@ -26,6 +28,7 @@ class Indicator:
         self.attrs = attrs
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Call the indicator function."""
         return self.func(*args, **kwargs)
 
 
@@ -39,6 +42,7 @@ class PluginMeta(type):
     __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] = {
@@ -76,6 +80,7 @@ class PluginMeta(type):
         return new_cls
 
     def __iter__(cls: Type["PluginMeta"]) -> Iterator[Indicator]:  # type: ignore
+        """Iterate over the indicators."""
         return iter(cls.__indicators__)
 
     # pylint: disable=unused-argument
@@ -88,11 +93,11 @@ class PltTA(metaclass=PluginMeta):
 
     indicators: ChartIndicators
     intraday: bool = False
-    df_stock: pd.DataFrame
-    df_ta: pd.DataFrame
+    df_stock: Union[pd.DataFrame, pd.Series]
+    df_ta: Optional[pd.DataFrame] = None
     df_fib: pd.DataFrame
     close_column: Optional[str] = "close"
-    params: Dict[str, TAIndicator] = {}
+    params: Optional[Dict[str, TAIndicator]] = {}
     inchart_colors: List[str] = []
     show_volume: bool = True
 
@@ -104,6 +109,7 @@ class PltTA(metaclass=PluginMeta):
 
     # 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)
@@ -132,6 +138,7 @@ class PltTA(metaclass=PluginMeta):
 
     @property
     def ma_mode(self) -> List[str]:
+        """Moving average mode."""
         return list(set(self.__ma_mode__))
 
     @ma_mode.setter
@@ -139,7 +146,7 @@ class PltTA(metaclass=PluginMeta):
         self.__ma_mode__ = value
 
     def add_plugins(self, plugins: List["PltTA"]) -> None:
-        """Add plugins to current instance"""
+        """Add plugins to current instance."""
         for plugin in plugins:
             for item in plugin.__indicators__:
                 # pylint: disable=unnecessary-dunder-call
@@ -161,7 +168,7 @@ class PltTA(metaclass=PluginMeta):
                     getattr(self, attr).extend(value)
 
     def remove_plugins(self, plugins: List["PltTA"]) -> None:
-        """Remove plugins from current instance"""
+        """Remove plugins from current instance."""
         for plugin in plugins:
             for item in plugin.__indicators__:
                 delattr(self, item.name)
@@ -171,10 +178,11 @@ class PltTA(metaclass=PluginMeta):
                 delattr(self, static_method)
 
     def __iter__(self) -> Iterator[Indicator]:
+        """Iterate over the indicators."""
         return iter(self.__indicators__)
 
     def get_float_precision(self) -> str:
-        """Returns f-string precision format"""
+        """Returns 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"

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/openbb_charting/core/plotly_ta/data_classes.py

@@ -67,10 +67,6 @@ class TAIndicator:
     ]
     args: List[Arguments]
 
-    def __post_init__(self):
-        """Post init."""
-        self.args = [Arguments(**arg) for arg in self.args]
-
     def __iter__(self):
         """Return iterator."""
         return iter(self.args)
@@ -98,14 +94,6 @@ class ChartIndicators:
 
     indicators: Optional[List[TAIndicator]] = None
 
-    def __post_init__(self):
-        """Post init."""
-        self.indicators = (
-            [TAIndicator(**indicator) for indicator in self.indicators]
-            if self.indicators
-            else []
-        )
-
     def get_indicator(self, name: str) -> Union[TAIndicator, None]:
         """Return indicator with given name."""
         output = None
@@ -165,21 +153,43 @@ class ChartIndicators:
     @staticmethod
     def get_available_indicators() -> Tuple[str, ...]:
         """Return tuple of available indicators."""
-        return list(
+        return tuple(
             TAIndicator.__annotations__["name"].__args__  # pylint: disable=E1101
         )
 
     @classmethod
-    def from_dict(cls, indicators: Dict[str, Dict[str, Any]]) -> "ChartIndicators":
-        """Return ChartIndicators from dictionary."""
-        data = []
-        for indicator in indicators:
-            args = []
-            for arg in indicators[indicator]:
-                args.append({"label": arg, "values": indicators[indicator][arg]})
-            data.append({"name": indicator, "args": args})
-
-        return cls(indicators=data)  # type: ignore
+    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: pd.DataFrame, ma_mode: Optional[List[str]] = None

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/openbb_charting/core/plotly_ta/ta_class.py

@@ -88,7 +88,7 @@ class PlotlyTA(PltTA):
 
     inchart_colors: List[str] = []
     plugins: List[Type[PltTA]] = []
-    df_ta: pd.DataFrame = None
+    df_ta: Optional[pd.DataFrame] = None
     close_column: Optional[str] = "close"
     has_volume: bool = True
     show_volume: bool = True
@@ -112,11 +112,11 @@ class PlotlyTA(PltTA):
             # 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 = 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)
+            PLOTLY_TA.add_plugins(PLOTLY_TA.plugins)  # type: ignore[attr-defined, assignment]
 
         return PLOTLY_TA
 
@@ -180,7 +180,13 @@ class PlotlyTA(PltTA):
             df_stock = df_stock.to_frame()
 
         if not isinstance(indicators, ChartIndicators):
-            indicators = ChartIndicators.from_dict(indicators or dict(dict()))
+            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()
@@ -283,7 +289,7 @@ class PlotlyTA(PltTA):
     def _clear_data(self):
         """Clear and reset all data to default values."""
         self.df_stock = None
-        self.indicators = {}
+        self.indicators = ChartIndicators.from_dict({})
         self.params = None
         self.intraday = False
         self.show_volume = True

openbb_charting-2.0.2/openbb_charting/query_params.py

@@ -0,0 +1,105 @@
+"""Charting Extension Query Params."""
+
+from typing import List, Optional, Union
+
+from openbb_core.provider.abstract.data import Data
+from openbb_core.provider.abstract.query_params import QueryParams
+from pydantic import Field
+
+
+class FredSeriesChartQueryParams(QueryParams):
+    """
+    FRED Series Chart Query Params.
+
+    kwargs
+    ------
+
+        data : List[Data], optional
+            Filtered versions of the data contained in the original results.
+            Example use is to reduce the number of columns or the length of data to plot.
+            To supply additional columns, set `allow_unsafe = True`.
+        title : str, optional
+            Title of the chart.
+        y1title : str, optional
+            Right Y-axis title.
+        y2title : str, optional
+            Left Y-axis title.
+        xtitle : str, optional
+            X-axis title.
+        dropnan: bool, optional (default: True)
+            If True, rows containing NaN will be dropped.
+        normalize: bool, optional (default: False)
+            If True, the data will be normalized and placed on the same axis.
+        allow_unsafe: bool, optional (default: False)
+            If True, the method will attempt to pass all supplied data to the chart constructor.
+            This can result in unexpected behavior.
+    """
+
+    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."
+        + " To supply additional columns, set `allow_unsafe = True`.",
+    )
+    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.",
+    )
+
+
+class TechnicalConesChartQueryParams(QueryParams):
+    """
+    Technical Cones Chart Query Params.
+
+    kwargs
+    ------
+
+        data : List[Data], optional
+            Filtered versions of the data contained in the original results.
+            Example use is to reduce the number of windows to plot.
+        title : str, optional
+            Title of the chart.
+        symbol: str, optional
+            Symbol represented by the data. Used to label the chart.
+    """
+
+    data: Optional[Union[Data, List[Data]]] = Field(
+        default=None,
+        description="Filtered versions of the data contained in the original 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: 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.",
+    )

{openbb_charting-2.0.0 → openbb_charting-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openbb-charting"
-version = "2.0.0"
+version = "2.0.2"
 description = "Charting extension for OpenBB"
 authors = ["OpenBB Team <hello@openbb.co>"]
 readme = "README.md"
@@ -16,7 +16,7 @@ pywry = "^0.6.1"
 svglib = "^1.5.1"
 nbformat = "^5.9.2"
 pandas-ta = "^0.3.14b"
-openbb-core = "^1.1.2"
+openbb-core = "^1.1.5"
 
 [build-system]
 requires = ["poetry-core"]

openbb_charting-2.0.0/openbb_charting/charting_router.py

@@ -1,176 +0,0 @@
-"""Charting router."""
-
-from typing import TYPE_CHECKING, Any, Dict, Tuple
-
-from openbb_core.app.model.charts.chart import ChartFormat
-from openbb_core.app.utils import basemodel_to_df
-
-from .core.plotly_ta.ta_class import PlotlyTA
-
-CHART_FORMAT = ChartFormat.plotly
-
-if TYPE_CHECKING:
-    from .core.openbb_figure import OpenBBFigure
-
-    # from .core.openbb_figure_table import OpenBBFigureTable
-
-
-def equity_price_historical(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Equity price chart."""
-
-    def handle_indicators(ma):
-        """Handle indicators."""
-        k = {}
-        if ma:
-            k["rma"] = dict(length=ma)
-        return k
-
-    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
-    standard_params = kwargs["standard_params"]
-    ma = standard_params.get("ma", None)
-    prepost = standard_params.get("prepost", False)
-    symbol = standard_params.get("symbol", "")
-
-    ta = PlotlyTA()
-    fig = ta.plot(
-        data,
-        indicators=dict(**handle_indicators(ma)),
-        symbol=f"{symbol} historical data",
-        prepost=prepost,
-    )
-    content = fig.show(external=True).to_plotly_json()
-
-    return fig, content
-
-
-def _ta_ma(ma_type: str, **kwargs):
-    """Plot moving average helper."""
-    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
-    window = kwargs.get("window", 50)
-    offset = kwargs.get("offset", 0)
-    symbol = kwargs.get("symbol", "")
-
-    ta = PlotlyTA()
-    fig = ta.plot(
-        data,
-        {f"{ma_type.lower()}": dict(length=window, offset=offset)},
-        f"{symbol.upper()} {ma_type.upper()}",
-        False,
-        volume=False,
-    )
-    content = fig.show(external=True).to_plotly_json()
-
-    return fig, content
-
-
-def technical_zlma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Zero lag moving average chart."""
-    ma_type = "zlma"
-    return _ta_ma(ma_type, **kwargs)
-
-
-def technical_aroon(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Aroon chart."""
-    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
-    length = kwargs.get("length", 25)
-    scalar = kwargs.get("scalar", 100)
-    symbol = kwargs.get("symbol", "")
-
-    ta = PlotlyTA()
-    fig = ta.plot(
-        data,
-        dict(aroon=dict(length=length, scalar=scalar)),
-        f"Aroon on {symbol}",
-        False,
-        volume=False,
-    )
-    content = fig.show(external=True).to_plotly_json()
-
-    return fig, content
-
-
-def technical_sma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Plot simple moving average chart."""
-    ma_type = "sma"
-    return _ta_ma(ma_type, **kwargs)
-
-
-def technical_macd(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Plot moving average convergence divergence chart."""
-    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
-    fast = kwargs.get("fast", 12)
-    slow = kwargs.get("slow", 26)
-    signal = kwargs.get("signal", 9)
-    symbol = kwargs.get("symbol", "")
-
-    ta = PlotlyTA()
-    fig = ta.plot(
-        data,
-        dict(macd=dict(fast=fast, slow=slow, signal=signal)),
-        f"{symbol.upper()} MACD",
-        False,
-        volume=False,
-    )
-    content = fig.show(external=True).to_plotly_json()
-
-    return fig, content
-
-
-def technical_hma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Hull moving average chart."""
-    ma_type = "hma"
-    return _ta_ma(ma_type, **kwargs)
-
-
-def technical_adx(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Average directional movement index chart."""
-    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
-    length = kwargs.get("length", 14)
-    scalar = kwargs.get("scalar", 100.0)
-    drift = kwargs.get("drift", 1)
-    symbol = kwargs.get("symbol", "")
-
-    ta = PlotlyTA()
-    fig = ta.plot(
-        data,
-        dict(adx=dict(length=length, scalar=scalar, drift=drift)),
-        f"Average Directional Movement Index (ADX) {symbol}",
-        False,
-        volume=False,
-    )
-    content = fig.show(external=True).to_plotly_json()
-
-    return fig, content
-
-
-def technical_wma(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Weighted moving average chart."""
-    ma_type = "wma"
-    return _ta_ma(ma_type, **kwargs)
-
-
-def technical_rsi(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Relative strength index chart."""
-    data = basemodel_to_df(kwargs["obbject_item"], index=kwargs.get("index", "date"))
-    window = kwargs.get("window", 14)
-    scalar = kwargs.get("scalar", 100.0)
-    drift = kwargs.get("drift", 1)
-    symbol = kwargs.get("symbol", "")
-
-    ta = PlotlyTA()
-    fig = ta.plot(
-        data,
-        dict(rsi=dict(length=window, scalar=scalar, drift=drift)),
-        f"{symbol.upper()} RSI {window}",
-        False,
-        volume=False,
-    )
-    content = fig.show(external=True).to_plotly_json()
-
-    return fig, content
-
-
-def technical_ema(**kwargs) -> Tuple["OpenBBFigure", Dict[str, Any]]:
-    """Exponential moving average chart."""
-    ma_type = "ema"
-    return _ta_ma(ma_type, **kwargs)