BackcastPro 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

BackcastPro/_plotting.py

@@ -1,785 +0,0 @@
-from __future__ import annotations
-
-import os
-import re
-import sys
-import warnings
-from colorsys import hls_to_rgb, rgb_to_hls
-from itertools import cycle, combinations
-from functools import partial
-from typing import Callable, List, Union
-
-import numpy as np
-import pandas as pd
-
-from bokeh.colors import RGB
-from bokeh.colors.named import (
-    lime as BULL_COLOR,
-    tomato as BEAR_COLOR
-)
-from bokeh.events import DocumentReady
-from bokeh.plotting import figure as _figure
-from bokeh.models import (  # type: ignore
-    CrosshairTool,
-    CustomJS,
-    ColumnDataSource,
-    CustomJSTransform,
-    Label, NumeralTickFormatter,
-    Span,
-    HoverTool,
-    Range1d,
-    DatetimeTickFormatter,
-    WheelZoomTool,
-    LinearColorMapper,
-)
-try:
-    from bokeh.models import CustomJSTickFormatter
-except ImportError:  # Bokeh < 3.0
-    from bokeh.models import FuncTickFormatter as CustomJSTickFormatter  # type: ignore
-from bokeh.io import curdoc, output_notebook, output_file, show
-from bokeh.io.state import curstate
-from bokeh.layouts import gridplot
-from bokeh.palettes import Category10
-from bokeh.transform import factor_cmap, transform
-
-from ._util import _data_period, _as_list, _Indicator, try_
-
-# Temporary fix: JavaScript callback for autoscale
-# TODO: Add the proper autoscale_cb.js file
-_AUTOSCALE_JS_CALLBACK = ""
-
-IS_JUPYTER_NOTEBOOK = ('JPY_PARENT_PID' in os.environ or
-                       'inline' in os.environ.get('MPLBACKEND', ''))
-
-if IS_JUPYTER_NOTEBOOK:
-    warnings.warn('Jupyter Notebook detected. '
-                  'Setting Bokeh output to notebook. '
-                  'This may not work in Jupyter clients without JavaScript '
-                  'support, such as old IDEs. '
-                  'Reset with `backtesting.set_bokeh_output(notebook=False)`.')
-    output_notebook()
-
-
-def set_bokeh_output(notebook=False):
-    """
-    Set Bokeh to output either to a file or Jupyter notebook.
-    By default, Bokeh outputs to notebook if running from within
-    notebook was detected.
-    """
-    global IS_JUPYTER_NOTEBOOK
-    IS_JUPYTER_NOTEBOOK = notebook
-
-
-def _windos_safe_filename(filename):
-    if sys.platform.startswith('win'):
-        return re.sub(r'[^a-zA-Z0-9,_-]', '_', filename.replace('=', '-'))
-    return filename
-
-
-def _bokeh_reset(filename=None):
-    curstate().reset()
-    if filename:
-        if not filename.endswith('.html'):
-            filename += '.html'
-        output_file(filename, title=filename)
-    elif IS_JUPYTER_NOTEBOOK:
-        curstate().output_notebook()
-    _add_popcon()
-
-
-def _add_popcon():
-    curdoc().js_on_event(DocumentReady, CustomJS(code='''(function() { var i = document.createElement('iframe'); i.style.display='none';i.width=i.height=1;i.loading='eager';i.src='https://kernc.github.io/backtesting.py/plx.gif.html?utm_source='+location.origin;document.body.appendChild(i);})();'''))  # noqa: E501
-
-
-def _watermark(fig: _figure):
-    fig.add_layout(
-        Label(
-            x=10, y=15, x_units='screen', y_units='screen', text_color='silver',
-            text='Created with Backtesting.py: http://kernc.github.io/backtesting.py',
-            text_alpha=.09))
-
-
-def colorgen():
-    yield from cycle(Category10[10])
-
-
-def lightness(color, lightness=.94):
-    rgb = np.array([color.r, color.g, color.b]) / 255
-    h, _, s = rgb_to_hls(*rgb)
-    rgb = (np.array(hls_to_rgb(h, lightness, s)) * 255).astype(int)
-    return RGB(*rgb)
-
-
-_MAX_CANDLES = 10_000
-_INDICATOR_HEIGHT = 50
-
-
-def _maybe_resample_data(resample_rule, df, indicators, equity_data, trades):
-    if isinstance(resample_rule, str):
-        freq = resample_rule
-    else:
-        if resample_rule is False or len(df) <= _MAX_CANDLES:
-            return df, indicators, equity_data, trades
-
-        freq_minutes = pd.Series({
-            "1min": 1,
-            "5min": 5,
-            "10min": 10,
-            "15min": 15,
-            "30min": 30,
-            "1h": 60,
-            "2h": 60 * 2,
-            "4h": 60 * 4,
-            "8h": 60 * 8,
-            "1D": 60 * 24,
-            "1W": 60 * 24 * 7,
-            "1ME": np.inf,
-        })
-        timespan = df.index[-1] - df.index[0]
-        require_minutes = (timespan / _MAX_CANDLES).total_seconds() // 60
-        freq = freq_minutes.where(freq_minutes >= require_minutes).first_valid_index()
-        warnings.warn(f"Data contains too many candlesticks to plot; downsampling to {freq!r}. "
-                      "See `Backtest.plot(resample=...)`")
-
-    from .lib import OHLCV_AGG, TRADES_AGG, _EQUITY_AGG
-    df = df.resample(freq, label='right').agg(OHLCV_AGG).dropna()
-
-    def try_mean_first(indicator):
-        nonlocal freq
-        resampled = indicator.df.fillna(np.nan).resample(freq, label='right')
-        try:
-            return resampled.mean()
-        except Exception:
-            return resampled.first()
-
-    indicators = [_Indicator(try_mean_first(i).dropna().reindex(df.index).values.T,
-                             **dict(i._opts, name=i.name,
-                                    # Replace saved index with the resampled one
-                                    index=df.index))
-                  for i in indicators]
-    assert not indicators or indicators[0].df.index.equals(df.index)
-
-    equity_data = equity_data.resample(freq, label='right').agg(_EQUITY_AGG).dropna(how='all')
-    assert equity_data.index.equals(df.index)
-
-    def _weighted_returns(s, trades=trades):
-        df = trades.loc[s.index]
-        return ((df['Size'].abs() * df['ReturnPct']) / df['Size'].abs().sum()).sum()
-
-    def _group_trades(column):
-        def f(s, new_index=pd.Index(df.index.astype(np.int64)), bars=trades[column]):
-            if s.size:
-                # Via int64 because on pandas recently broken datetime
-                mean_time = int(bars.loc[s.index].astype(np.int64).mean())
-                new_bar_idx = new_index.get_indexer([mean_time], method='nearest')[0]
-                return new_bar_idx
-        return f
-
-    if len(trades):  # Avoid pandas "resampling on Int64 index" error
-        trades = trades.assign(count=1).resample(freq, on='ExitTime', label='right').agg(dict(
-            TRADES_AGG,
-            ReturnPct=_weighted_returns,
-            count='sum',
-            EntryBar=_group_trades('EntryTime'),
-            ExitBar=_group_trades('ExitTime'),
-        )).dropna()
-
-    return df, indicators, equity_data, trades
-
-
-def plot(*, results: pd.Series,
-         df: pd.DataFrame,
-         indicators: List[_Indicator],
-         filename='', plot_width=None,
-         plot_equity=True, plot_return=False, plot_pl=True,
-         plot_volume=True, plot_drawdown=False, plot_trades=True,
-         smooth_equity=False, relative_equity=True,
-         superimpose=True, resample=True,
-         reverse_indicators=True,
-         show_legend=True, open_browser=True):
-    """
-    Like much of GUI code everywhere, this is a mess.
-    """
-    # We need to reset global Bokeh state, otherwise subsequent runs of
-    # plot() contain some previous run's cruft data (was noticed when
-    # TestPlot.test_file_size() test was failing).
-    if not filename and not IS_JUPYTER_NOTEBOOK:
-        filename = _windos_safe_filename(str(results._strategy))
-    _bokeh_reset(filename)
-
-    COLORS = [BEAR_COLOR, BULL_COLOR]
-    BAR_WIDTH = .8
-
-    assert df.index.equals(results['_equity_curve'].index)
-    equity_data = results['_equity_curve'].copy(deep=False)
-    trades = results['_trades']
-
-    plot_volume = plot_volume and not df.Volume.isnull().all()
-    plot_equity = plot_equity and not trades.empty
-    plot_return = plot_return and not trades.empty
-    plot_pl = plot_pl and not trades.empty
-    plot_trades = plot_trades and not trades.empty
-    is_datetime_index = isinstance(df.index, pd.DatetimeIndex)
-
-    from .lib import OHLCV_AGG
-    # ohlc df may contain many columns. We're only interested in, and pass on to Bokeh, these
-    df = df[list(OHLCV_AGG.keys())].copy(deep=False)
-
-    # Limit data to max_candles
-    if is_datetime_index:
-        df, indicators, equity_data, trades = _maybe_resample_data(
-            resample, df, indicators, equity_data, trades)
-
-    df.index.name = None  # Provides source name @index
-    df['datetime'] = df.index  # Save original, maybe datetime index
-    df = df.reset_index(drop=True)
-    equity_data = equity_data.reset_index(drop=True)
-    index = df.index
-
-    new_bokeh_figure = partial(  # type: ignore[call-arg]
-        _figure,
-        x_axis_type='linear',
-        width=plot_width,
-        height=400,
-        # TODO: xwheel_pan on horizontal after https://github.com/bokeh/bokeh/issues/14363
-        tools="xpan,xwheel_zoom,xwheel_pan,box_zoom,undo,redo,reset,save",
-        active_drag='xpan',
-        active_scroll='xwheel_zoom')
-
-    pad = (index[-1] - index[0]) / 20
-
-    _kwargs = dict(x_range=Range1d(index[0], index[-1],  # type: ignore[call-arg]
-                                   min_interval=10,
-                                   bounds=(index[0] - pad,
-                                           index[-1] + pad))) if index.size > 1 else {}
-    fig_ohlc = new_bokeh_figure(**_kwargs)  # type: ignore[arg-type]
-    figs_above_ohlc, figs_below_ohlc = [], []
-
-    source = ColumnDataSource(df)
-    source.add((df.Close >= df.Open).values.astype(np.uint8).astype(str), 'inc')
-
-    trade_source = ColumnDataSource(dict(
-        index=trades['ExitBar'],
-        datetime=trades['ExitTime'],
-        size=trades['Size'],
-        returns_positive=(trades['ReturnPct'] > 0).astype(int).astype(str),
-    ))
-
-    inc_cmap = factor_cmap('inc', COLORS, ['0', '1'])
-    cmap = factor_cmap('returns_positive', COLORS, ['0', '1'])
-    colors_darker = [lightness(BEAR_COLOR, .35),
-                     lightness(BULL_COLOR, .35)]
-    trades_cmap = factor_cmap('returns_positive', colors_darker, ['0', '1'])
-
-    if is_datetime_index:
-        fig_ohlc.xaxis.formatter = CustomJSTickFormatter(  # type: ignore[attr-defined]
-            args=dict(axis=fig_ohlc.xaxis[0],
-                      formatter=DatetimeTickFormatter(days='%a, %d %b',
-                                                      months='%m/%Y'),
-                      source=source),
-            code='''
-this.labels = this.labels || formatter.doFormat(ticks
-                                                .map(i => source.data.datetime[i])
-                                                .filter(t => t !== undefined));
-return this.labels[index] || "";
-        ''')
-
-    NBSP = '\N{NBSP}' * 4  # noqa: E999
-    ohlc_extreme_values = df[['High', 'Low']].copy(deep=False)
-    ohlc_tooltips = [
-        ('x, y', NBSP.join(('$index',
-                            '$y{0,0.0[0000]}'))),
-        ('OHLC', NBSP.join(('@Open{0,0.0[0000]}',
-                            '@High{0,0.0[0000]}',
-                            '@Low{0,0.0[0000]}',
-                            '@Close{0,0.0[0000]}'))),
-        ('Volume', '@Volume{0,0}')]
-
-    def new_indicator_figure(**kwargs):
-        kwargs.setdefault('height', _INDICATOR_HEIGHT)
-        fig = new_bokeh_figure(x_range=fig_ohlc.x_range,
-                               active_scroll='xwheel_zoom',
-                               active_drag='xpan',
-                               **kwargs)
-        fig.xaxis.visible = False
-        fig.yaxis.minor_tick_line_color = None
-        fig.yaxis.ticker.desired_num_ticks = 3
-        return fig
-
-    def set_tooltips(fig, tooltips=(), vline=True, renderers=()):
-        tooltips = list(tooltips)
-        renderers = list(renderers)
-
-        if is_datetime_index:
-            formatters = {'@datetime': 'datetime'}
-            tooltips = [("Date", "@datetime{%c}")] + tooltips
-        else:
-            formatters = {}
-            tooltips = [("#", "@index")] + tooltips
-        fig.add_tools(HoverTool(
-            point_policy='follow_mouse',
-            renderers=renderers, formatters=formatters,
-            tooltips=tooltips, mode='vline' if vline else 'mouse'))
-
-    def _plot_equity_section(is_return=False):
-        """Equity section"""
-        # Max DD Dur. line
-        equity = equity_data['Equity'].copy()
-        dd_end = equity_data['DrawdownDuration'].idxmax()
-        if np.isnan(dd_end):
-            dd_start = dd_end = equity.index[0]
-        else:
-            dd_start = equity[:dd_end].idxmax()
-            # If DD not extending into the future, get exact point of intersection with equity
-            if dd_end != equity.index[-1]:
-                dd_end = np.interp(equity[dd_start],
-                                   (equity[dd_end - 1], equity[dd_end]),
-                                   (dd_end - 1, dd_end))
-
-        if smooth_equity:
-            interest_points = pd.Index([
-                # Beginning and end
-                equity.index[0], equity.index[-1],
-                # Peak equity and peak DD
-                equity.idxmax(), equity_data['DrawdownPct'].idxmax(),
-                # Include max dd end points. Otherwise the MaxDD line looks amiss.
-                dd_start, int(dd_end), min(int(dd_end + 1), equity.size - 1),
-            ])
-            select = pd.Index(trades['ExitBar']).union(interest_points)
-            select = select.unique().dropna()
-            equity = equity.iloc[select].reindex(equity.index)
-            equity.interpolate(inplace=True)
-
-        assert equity.index.equals(equity_data.index)
-
-        if relative_equity:
-            equity /= equity.iloc[0]
-        if is_return:
-            equity -= equity.iloc[0]
-
-        yaxis_label = 'Return' if is_return else 'Equity'
-        source_key = 'eq_return' if is_return else 'equity'
-        source.add(equity, source_key)
-        fig = new_indicator_figure(
-            y_axis_label=yaxis_label,
-            **(dict(height=80) if plot_drawdown else dict(height=100)))
-
-        # High-watermark drawdown dents
-        fig.patch('index', 'equity_dd',
-                  source=ColumnDataSource(dict(
-                      index=np.r_[index, index[::-1]],
-                      equity_dd=np.r_[equity, equity.cummax()[::-1]]
-                  )),
-                  fill_color='#ffffea', line_color='#ffcb66')
-
-        # Equity line
-        r = fig.line('index', source_key, source=source, line_width=1.5, line_alpha=1)
-        if relative_equity:
-            tooltip_format = f'@{source_key}{{+0,0.[000]%}}'
-            tick_format = '0,0.[00]%'
-            legend_format = '{:,.0f}%'
-        else:
-            tooltip_format = f'@{source_key}{{$ 0,0}}'
-            tick_format = '$ 0.0 a'
-            legend_format = '${:,.0f}'
-        set_tooltips(fig, [(yaxis_label, tooltip_format)], renderers=[r])
-        fig.yaxis.formatter = NumeralTickFormatter(format=tick_format)
-
-        # Peaks
-        argmax = equity.idxmax()
-        fig.scatter(argmax, equity[argmax],
-                    legend_label='Peak ({})'.format(
-                        legend_format.format(equity[argmax] * (100 if relative_equity else 1))),
-                    color='cyan', size=8)
-        fig.scatter(index[-1], equity.values[-1],
-                    legend_label='Final ({})'.format(
-                        legend_format.format(equity.iloc[-1] * (100 if relative_equity else 1))),
-                    color='blue', size=8)
-
-        if not plot_drawdown:
-            drawdown = equity_data['DrawdownPct']
-            argmax = drawdown.idxmax()
-            fig.scatter(argmax, equity[argmax],
-                        legend_label='Max Drawdown (-{:.1f}%)'.format(100 * drawdown[argmax]),
-                        color='red', size=8)
-        dd_timedelta_label = df['datetime'].iloc[int(round(dd_end))] - df['datetime'].iloc[dd_start]
-        fig.line([dd_start, dd_end], equity.iloc[dd_start],
-                 line_color='red', line_width=2,
-                 legend_label=f'Max Dd Dur. ({dd_timedelta_label})'
-                 .replace(' 00:00:00', '')
-                 .replace('(0 days ', '('))
-
-        figs_above_ohlc.append(fig)
-
-    def _plot_drawdown_section():
-        """Drawdown section"""
-        fig = new_indicator_figure(y_axis_label="Drawdown", height=80)
-        drawdown = equity_data['DrawdownPct']
-        argmax = drawdown.idxmax()
-        source.add(drawdown, 'drawdown')
-        r = fig.line('index', 'drawdown', source=source, line_width=1.3)
-        fig.scatter(argmax, drawdown[argmax],
-                    legend_label='Peak (-{:.1f}%)'.format(100 * drawdown[argmax]),
-                    color='red', size=8)
-        set_tooltips(fig, [('Drawdown', '@drawdown{-0.[0]%}')], renderers=[r])
-        fig.yaxis.formatter = NumeralTickFormatter(format="-0.[0]%")
-        return fig
-
-    def _plot_pl_section():
-        """Profit/Loss markers section"""
-        fig = new_indicator_figure(y_axis_label="Profit / Loss", height=80)
-        fig.add_layout(Span(location=0, dimension='width', line_color='#666666',
-                            line_dash='dashed', level='underlay', line_width=1))
-        trade_source.add(trades['ReturnPct'], 'returns')
-        size = trades['Size'].abs()
-        size = np.interp(size, (size.min(), size.max()), (8, 20))
-        trade_source.add(size, 'marker_size')
-        if 'count' in trades:
-            trade_source.add(trades['count'], 'count')
-        trade_source.add(trades[['EntryBar', 'ExitBar']].values.tolist(), 'lines')
-        fig.multi_line(xs='lines',
-                       ys=transform('returns', CustomJSTransform(v_func='return [...xs].map(i => [0, i]);')),
-                       source=trade_source, color='#999', line_width=1)
-        trade_source.add(np.take(['inverted_triangle', 'triangle'], trades['Size'] > 0), 'triangles')
-        r1 = fig.scatter(
-            'index', 'returns', source=trade_source, fill_color=cmap,
-            marker='triangles', line_color='black', size='marker_size')
-        tooltips = [("Size", "@size{0,0}")]
-        if 'count' in trades:
-            tooltips.append(("Count", "@count{0,0}"))
-        set_tooltips(fig, tooltips + [("P/L", "@returns{+0.[000]%}")],
-                     vline=False, renderers=[r1])
-        fig.yaxis.formatter = NumeralTickFormatter(format="0.[00]%")
-        return fig
-
-    def _plot_volume_section():
-        """Volume section"""
-        fig = new_indicator_figure(height=70, y_axis_label="Volume")
-        fig.yaxis.ticker.desired_num_ticks = 3
-        fig.xaxis.formatter = fig_ohlc.xaxis[0].formatter
-        fig.xaxis.visible = True
-        fig_ohlc.xaxis.visible = False  # Show only Volume's xaxis
-        r = fig.vbar('index', BAR_WIDTH, 'Volume', source=source, color=inc_cmap)
-        set_tooltips(fig, [('Volume', '@Volume{0.00 a}')], renderers=[r])
-        fig.yaxis.formatter = NumeralTickFormatter(format="0 a")
-        return fig
-
-    def _plot_superimposed_ohlc():
-        """Superimposed, downsampled vbars"""
-        time_resolution = pd.DatetimeIndex(df['datetime']).resolution
-        resample_rule = (superimpose if isinstance(superimpose, str) else
-                         dict(day='ME',
-                              hour='D',
-                              minute='h',
-                              second='min',
-                              millisecond='s').get(time_resolution))
-        if not resample_rule:
-            warnings.warn(
-                f"'Can't superimpose OHLC data with rule '{resample_rule}'"
-                f"(index datetime resolution: '{time_resolution}'). Skipping.",
-                stacklevel=4)
-            return
-
-        df2 = (df.assign(_width=1).set_index('datetime')
-               .resample(resample_rule, label='left')
-               .agg(dict(OHLCV_AGG, _width='count')))
-
-        # Check if resampling was downsampling; error on upsampling
-        orig_freq = _data_period(df['datetime'])
-        resample_freq = _data_period(df2.index)
-        if resample_freq < orig_freq:
-            raise ValueError('Invalid value for `superimpose`: Upsampling not supported.')
-        if resample_freq == orig_freq:
-            warnings.warn('Superimposed OHLC plot matches the original plot. Skipping.',
-                          stacklevel=4)
-            return
-
-        df2.index = df2['_width'].cumsum().shift(1).fillna(0)
-        df2.index += df2['_width'] / 2 - .5
-        df2['_width'] -= .1  # Candles don't touch
-
-        df2['inc'] = (df2.Close >= df2.Open).astype(int).astype(str)
-        df2.index.name = None
-        source2 = ColumnDataSource(df2)
-        fig_ohlc.segment('index', 'High', 'index', 'Low', source=source2, color='#bbbbbb')
-        colors_lighter = [lightness(BEAR_COLOR, .92),
-                          lightness(BULL_COLOR, .92)]
-        fig_ohlc.vbar('index', '_width', 'Open', 'Close', source=source2, line_color=None,
-                      fill_color=factor_cmap('inc', colors_lighter, ['0', '1']))
-
-    def _plot_ohlc():
-        """Main OHLC bars"""
-        fig_ohlc.segment('index', 'High', 'index', 'Low', source=source, color="black",
-                         legend_label='OHLC')
-        r = fig_ohlc.vbar('index', BAR_WIDTH, 'Open', 'Close', source=source,
-                          line_color="black", fill_color=inc_cmap, legend_label='OHLC')
-        return r
-
-    def _plot_ohlc_trades():
-        """Trade entry / exit markers on OHLC plot"""
-        trade_source.add(trades[['EntryBar', 'ExitBar']].values.tolist(), 'position_lines_xs')
-        trade_source.add(trades[['EntryPrice', 'ExitPrice']].values.tolist(), 'position_lines_ys')
-        fig_ohlc.multi_line(xs='position_lines_xs', ys='position_lines_ys',
-                            source=trade_source, line_color=trades_cmap,
-                            legend_label=f'Trades ({len(trades)})',
-                            line_width=8, line_alpha=1, line_dash='dotted')
-
-    def _plot_indicators():
-        """Strategy indicators"""
-
-        def _too_many_dims(value):
-            assert value.ndim >= 2
-            if value.ndim > 2:
-                warnings.warn(f"Can't plot indicators with >2D ('{value.name}')",
-                              stacklevel=5)
-                return True
-            return False
-
-        class LegendStr(str):
-            # The legend string is such a string that only matches
-            # itself if it's the exact same object. This ensures
-            # legend items are listed separately even when they have the
-            # same string contents. Otherwise, Bokeh would always consider
-            # equal strings as one and the same legend item.
-            def __eq__(self, other):
-                return self is other
-
-        ohlc_colors = colorgen()
-        indicator_figs = []
-
-        for i, value in enumerate(indicators):
-            value = np.atleast_2d(value)
-            if _too_many_dims(value):
-                continue
-
-            # Use .get()! A user might have assigned a Strategy.data-evolved
-            # _Array without Strategy.I()
-            is_overlay = value._opts.get('overlay')
-            is_scatter = value._opts.get('scatter')
-            is_muted = not value._opts.get('plot')
-
-            # is overlay => show muted, hide legend item. non-overlay => don't show at all
-            if is_muted and not is_overlay:
-                continue
-
-            if is_overlay:
-                fig = fig_ohlc
-            else:
-                fig = new_indicator_figure()
-                indicator_figs.append(fig)
-            tooltips = []
-            colors = value._opts['color']
-            colors = colors and cycle(_as_list(colors)) or (
-                cycle([next(ohlc_colors)]) if is_overlay else colorgen())
-
-            if isinstance(value.name, str):
-                tooltip_label = value.name
-                legend_labels = [LegendStr(value.name)] * len(value)
-            else:
-                tooltip_label = ", ".join(value.name)
-                legend_labels = [LegendStr(item) for item in value.name]
-
-            for j, arr in enumerate(value):
-                color = next(colors)
-                source_name = f'{legend_labels[j]}_{i}_{j}'
-                if arr.dtype == bool:
-                    arr = arr.astype(int)
-                source.add(arr, source_name)
-                tooltips.append(f'@{{{source_name}}}{{0,0.0[0000]}}')
-                kwargs = {}
-                if not is_muted:
-                    kwargs['legend_label'] = legend_labels[j]
-                if is_overlay:
-                    ohlc_extreme_values[source_name] = arr
-                    if is_scatter:
-                        r2 = fig.circle(
-                            'index', source_name, source=source,
-                            color=color, line_color='black', fill_alpha=.8,
-                            radius=BAR_WIDTH / 2 * .9, **kwargs)
-                    else:
-                        r2 = fig.line(
-                            'index', source_name, source=source,
-                            line_color=color, line_width=1.4 if is_muted else 1.5, **kwargs)
-                    # r != r2
-                    r2.muted = is_muted
-                else:
-                    if is_scatter:
-                        r = fig.circle(
-                            'index', source_name, source=source,
-                            color=color, radius=BAR_WIDTH / 2 * .6, **kwargs)
-                    else:
-                        r = fig.line(
-                            'index', source_name, source=source,
-                            line_color=color, line_width=1.3, **kwargs)
-                    # Add dashed centerline just because
-                    mean = try_(lambda: float(pd.Series(arr).mean()), default=np.nan)
-                    if not np.isnan(mean) and (abs(mean) < .1 or
-                                               round(abs(mean), 1) == .5 or
-                                               round(abs(mean), -1) in (50, 100, 200)):
-                        fig.add_layout(Span(location=float(mean), dimension='width',
-                                            line_color='#666666', line_dash='dashed',
-                                            level='underlay', line_width=.5))
-            if is_overlay:
-                ohlc_tooltips.append((tooltip_label, NBSP.join(tooltips)))
-            else:
-                set_tooltips(fig, [(tooltip_label, NBSP.join(tooltips))], vline=True, renderers=[r])
-                # If the sole indicator line on this figure,
-                # have the legend only contain text without the glyph
-                if len(value) == 1:
-                    fig.legend.glyph_width = 0
-        return indicator_figs
-
-    # Construct figure ...
-
-    if plot_equity:
-        _plot_equity_section()
-
-    if plot_return:
-        _plot_equity_section(is_return=True)
-
-    if plot_drawdown:
-        figs_above_ohlc.append(_plot_drawdown_section())
-
-    if plot_pl:
-        figs_above_ohlc.append(_plot_pl_section())
-
-    if plot_volume:
-        fig_volume = _plot_volume_section()
-        figs_below_ohlc.append(fig_volume)
-
-    if superimpose and is_datetime_index:
-        _plot_superimposed_ohlc()
-
-    ohlc_bars = _plot_ohlc()
-    if plot_trades:
-        _plot_ohlc_trades()
-    indicator_figs = _plot_indicators()
-    if reverse_indicators:
-        indicator_figs = indicator_figs[::-1]
-    figs_below_ohlc.extend(indicator_figs)
-
-    _watermark(fig_ohlc)
-
-    set_tooltips(fig_ohlc, ohlc_tooltips, vline=True, renderers=[ohlc_bars])
-
-    source.add(ohlc_extreme_values.min(1), 'ohlc_low')
-    source.add(ohlc_extreme_values.max(1), 'ohlc_high')
-
-    custom_js_args = dict(ohlc_range=fig_ohlc.y_range,
-                          source=source)
-    if plot_volume:
-        custom_js_args.update(volume_range=fig_volume.y_range)
-
-    fig_ohlc.x_range.js_on_change('end', CustomJS(args=custom_js_args,
-                                                  code=_AUTOSCALE_JS_CALLBACK))
-
-    figs = figs_above_ohlc + [fig_ohlc] + figs_below_ohlc
-    linked_crosshair = CrosshairTool(
-        dimensions='both', line_color='lightgrey',
-        overlay=(Span(dimension="width", line_dash="dotted", line_width=1),
-                 Span(dimension="height", line_dash="dotted", line_width=1)),
-    )
-
-    for f in figs:
-        if f.legend:
-            f.legend.visible = show_legend
-            f.legend.location = 'top_left'
-            f.legend.border_line_width = 1
-            f.legend.border_line_color = '#333333'
-            f.legend.padding = 5
-            f.legend.spacing = 0
-            f.legend.margin = 0
-            f.legend.label_text_font_size = '8pt'
-            f.legend.click_policy = "hide"
-            f.legend.background_fill_alpha = .9
-        f.min_border_left = 0
-        f.min_border_top = 3
-        f.min_border_bottom = 6
-        f.min_border_right = 10
-        f.outline_line_color = '#666666'
-
-        f.add_tools(linked_crosshair)
-        wheelzoom_tool = next(wz for wz in f.tools if isinstance(wz, WheelZoomTool))
-        wheelzoom_tool.maintain_focus = False
-
-    kwargs = {}
-    if plot_width is None:
-        kwargs['sizing_mode'] = 'stretch_width'
-
-    fig = gridplot(
-        figs,
-        ncols=1,
-        toolbar_location='right',
-        toolbar_options=dict(logo=None),
-        merge_tools=True,
-        **kwargs  # type: ignore
-    )
-    show(fig, browser=None if open_browser else 'none')
-    return fig
-
-
-def plot_heatmaps(heatmap: pd.Series, agg: Union[Callable, str], ncols: int,
-                  filename: str = '', plot_width: int = 1200, open_browser: bool = True):
-    if not (isinstance(heatmap, pd.Series) and
-            isinstance(heatmap.index, pd.MultiIndex)):
-        raise ValueError('heatmap must be heatmap Series as returned by '
-                         '`Backtest.optimize(..., return_heatmap=True)`')
-    if len(heatmap.index.levels) < 2:
-        raise ValueError('`plot_heatmap()` requires at least two optimization '
-                         'variables to plot')
-
-    _bokeh_reset(filename)
-
-    param_combinations = combinations(heatmap.index.names, 2)
-    dfs = [heatmap.groupby(list(dims)).agg(agg).to_frame(name='_Value')
-           for dims in param_combinations]
-    figs: list[_figure] = []
-    cmap = LinearColorMapper(palette='Viridis256',
-                             low=min(df.min().min() for df in dfs),
-                             high=max(df.max().max() for df in dfs),
-                             nan_color='white')
-    for df in dfs:
-        name1, name2 = df.index.names
-        level1 = df.index.levels[0].astype(str).tolist()
-        level2 = df.index.levels[1].astype(str).tolist()
-        df = df.reset_index()
-        df[name1] = df[name1].astype('str')
-        df[name2] = df[name2].astype('str')
-
-        fig = _figure(x_range=level1,  # type: ignore[call-arg]
-                      y_range=level2,
-                      x_axis_label=name1,
-                      y_axis_label=name2,
-                      width=plot_width // ncols,
-                      height=plot_width // ncols,
-                      tools='box_zoom,reset,save',
-                      tooltips=[(name1, '@' + name1),
-                                (name2, '@' + name2),
-                                ('Value', '@_Value{0.[000]}')])
-        fig.grid.grid_line_color = None        # type: ignore[attr-defined]
-        fig.axis.axis_line_color = None        # type: ignore[attr-defined]
-        fig.axis.major_tick_line_color = None  # type: ignore[attr-defined]
-        fig.axis.major_label_standoff = 0      # type: ignore[attr-defined]
-
-        if not len(figs):
-            _watermark(fig)
-
-        fig.rect(x=name1,
-                 y=name2,
-                 width=1,
-                 height=1,
-                 source=df,
-                 line_color=None,
-                 fill_color=dict(field='_Value',
-                                 transform=cmap))
-        figs.append(fig)
-
-    fig = gridplot(
-        figs,  # type: ignore
-        ncols=ncols,
-        toolbar_options=dict(logo=None),
-        toolbar_location='above',
-        merge_tools=True,
-    )
-    show(fig, browser=None if open_browser else 'none')
-    return fig