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

BackcastPro/backtesting.py

@@ -1,1763 +0,0 @@
-"""
-Core framework data structures.
-Objects from this module can also be imported from the top-level
-module directly, e.g.
-
-    from BackcastPro import Backtest, Strategy
-"""
-
-from __future__ import annotations
-
-import sys
-import warnings
-from abc import ABCMeta, abstractmethod
-from copy import copy
-from functools import lru_cache, partial
-from itertools import chain, product, repeat
-from math import copysign
-from numbers import Number
-from typing import Callable, List, Optional, Sequence, Tuple, Type, Union
-
-import numpy as np
-import pandas as pd
-from numpy.random import default_rng
-
-from ._plotting import plot  # noqa: I001
-from ._stats import compute_stats, dummy_stats
-from ._util import (
-    SharedMemoryManager, _as_str, _Indicator, _Data, _batch, _indicator_warmup_nbars,
-    _strategy_indicators, patch, try_, _tqdm,
-)
-
-__pdoc__ = {
-    'Strategy.__init__': False,
-    'Order.__init__': False,
-    'Position.__init__': False,
-    'Trade.__init__': False,
-}
-
-
-class Strategy(metaclass=ABCMeta):
-    """
-    A trading strategy base class. Extend this class and
-    override methods
-    `backtesting.backtesting.Strategy.init` and
-    `backtesting.backtesting.Strategy.next` to define
-    your own strategy.
-    """
-    def __init__(self, broker, data, params):
-        self._indicators = []
-        self._broker: _Broker = broker
-        self._data: _Data = data
-        self._params = self._check_params(params)
-
-    def __repr__(self):
-        return '<Strategy ' + str(self) + '>'
-
-    def __str__(self):
-        params = ','.join(f'{i[0]}={i[1]}' for i in zip(self._params.keys(),
-                                                        map(_as_str, self._params.values())))
-        if params:
-            params = '(' + params + ')'
-        return f'{self.__class__.__name__}{params}'
-
-    def _check_params(self, params):
-        for k, v in params.items():
-            if not hasattr(self, k):
-                raise AttributeError(
-                    f"Strategy '{self.__class__.__name__}' is missing parameter '{k}'."
-                    "Strategy class should define parameters as class variables before they "
-                    "can be optimized or run with.")
-            setattr(self, k, v)
-        return params
-
-    def I(self,  # noqa: E743
-          func: Callable, *args,
-          name=None, plot=True, overlay=None, color=None, scatter=False,
-          **kwargs) -> np.ndarray:
-        """
-        Declare an indicator. An indicator is just an array of values
-        (or a tuple of such arrays in case of, e.g., MACD indicator),
-        but one that is revealed gradually in
-        `backtesting.backtesting.Strategy.next` much like
-        `backtesting.backtesting.Strategy.data` is.
-        Returns `np.ndarray` of indicator values.
-
-        `func` is a function that returns the indicator array(s) of
-        same length as `backtesting.backtesting.Strategy.data`.
-
-        In the plot legend, the indicator is labeled with
-        function name, unless `name` overrides it. If `func` returns
-        a tuple of arrays, `name` can be a sequence of strings, and
-        its size must agree with the number of arrays returned.
-
-        If `plot` is `True`, the indicator is plotted on the resulting
-        `backtesting.backtesting.Backtest.plot`.
-
-        If `overlay` is `True`, the indicator is plotted overlaying the
-        price candlestick chart (suitable e.g. for moving averages).
-        If `False`, the indicator is plotted standalone below the
-        candlestick chart. By default, a heuristic is used which decides
-        correctly most of the time.
-
-        `color` can be string hex RGB triplet or X11 color name.
-        By default, the next available color is assigned.
-
-        If `scatter` is `True`, the plotted indicator marker will be a
-        circle instead of a connected line segment (default).
-
-        Additional `*args` and `**kwargs` are passed to `func` and can
-        be used for parameters.
-
-        For example, using simple moving average function from TA-Lib:
-
-            def init():
-                self.sma = self.I(ta.SMA, self.data.Close, self.n_sma)
-
-        .. warning::
-            Rolling indicators may front-pad warm-up values with NaNs.
-            In this case, the **backtest will only begin on the first bar when
-            all declared indicators have non-NaN values** (e.g. bar 201 for a
-            strategy that uses a 200-bar MA).
-            This can affect results.
-        """
-        def _format_name(name: str) -> str:
-            return name.format(*map(_as_str, args),
-                               **dict(zip(kwargs.keys(), map(_as_str, kwargs.values()))))
-
-        if name is None:
-            params = ','.join(filter(None, map(_as_str, chain(args, kwargs.values()))))
-            func_name = _as_str(func)
-            name = (f'{func_name}({params})' if params else f'{func_name}')
-        elif isinstance(name, str):
-            name = _format_name(name)
-        elif try_(lambda: all(isinstance(item, str) for item in name), False):
-            name = [_format_name(item) for item in name]
-        else:
-            raise TypeError(f'Unexpected `name=` type {type(name)}; expected `str` or '
-                            '`Sequence[str]`')
-
-        try:
-            value = func(*args, **kwargs)
-        except Exception as e:
-            raise RuntimeError(f'Indicator "{name}" error. See traceback above.') from e
-
-        if isinstance(value, pd.DataFrame):
-            value = value.values.T
-
-        if value is not None:
-            value = try_(lambda: np.asarray(value, order='C'), None)
-        is_arraylike = bool(value is not None and value.shape)
-
-        # Optionally flip the array if the user returned e.g. `df.values`
-        if is_arraylike and np.argmax(value.shape) == 0:
-            value = value.T
-
-        if isinstance(name, list) and (np.atleast_2d(value).shape[0] != len(name)):
-            raise ValueError(
-                f'Length of `name=` ({len(name)}) must agree with the number '
-                f'of arrays the indicator returns ({value.shape[0]}).')
-
-        if not is_arraylike or not 1 <= value.ndim <= 2 or value.shape[-1] != len(self._data.Close):
-            raise ValueError(
-                'Indicators must return (optionally a tuple of) numpy.arrays of same '
-                f'length as `data` (data shape: {self._data.Close.shape}; indicator "{name}" '
-                f'shape: {getattr(value, "shape", "")}, returned value: {value})')
-
-        if overlay is None and np.issubdtype(value.dtype, np.number):
-            x = value / self._data.Close
-            # By default, overlay if strong majority of indicator values
-            # is within 30% of Close
-            with np.errstate(invalid='ignore'):
-                overlay = ((x < 1.4) & (x > .6)).mean() > .6
-
-        value = _Indicator(value, name=name, plot=plot, overlay=overlay,
-                           color=color, scatter=scatter,
-                           # _Indicator.s Series accessor uses this:
-                           index=self.data.index)
-        self._indicators.append(value)
-        return value
-
-    @abstractmethod
-    def init(self):
-        """
-        Initialize the strategy.
-        Override this method.
-        Declare indicators (with `backtesting.backtesting.Strategy.I`).
-        Precompute what needs to be precomputed or can be precomputed
-        in a vectorized fashion before the strategy starts.
-
-        If you extend composable strategies from `backtesting.lib`,
-        make sure to call:
-
-            super().init()
-        """
-
-    @abstractmethod
-    def next(self):
-        """
-        Main strategy runtime method, called as each new
-        `backtesting.backtesting.Strategy.data`
-        instance (row; full candlestick bar) becomes available.
-        This is the main method where strategy decisions
-        upon data precomputed in `backtesting.backtesting.Strategy.init`
-        take place.
-
-        If you extend composable strategies from `backtesting.lib`,
-        make sure to call:
-
-            super().next()
-        """
-
-    class __FULL_EQUITY(float):  # noqa: N801
-        def __repr__(self): return '.9999'  # noqa: E704
-    _FULL_EQUITY = __FULL_EQUITY(1 - sys.float_info.epsilon)
-
-    def buy(self, *,
-            size: float = _FULL_EQUITY,
-            limit: Optional[float] = None,
-            stop: Optional[float] = None,
-            sl: Optional[float] = None,
-            tp: Optional[float] = None,
-            tag: object = None) -> 'Order':
-        """
-        Place a new long order and return it. For explanation of parameters, see `Order`
-        and its properties.
-        Unless you're running `Backtest(..., trade_on_close=True)`,
-        market orders are filled on next bar's open,
-        whereas other order types (limit, stop-limit, stop-market) are filled when
-        the respective conditions are met.
-
-        See `Position.close()` and `Trade.close()` for closing existing positions.
-
-        See also `Strategy.sell()`.
-        """
-        assert 0 < size < 1 or round(size) == size >= 1, \
-            "size must be a positive fraction of equity, or a positive whole number of units"
-        return self._broker.new_order(size, limit, stop, sl, tp, tag)
-
-    def sell(self, *,
-             size: float = _FULL_EQUITY,
-             limit: Optional[float] = None,
-             stop: Optional[float] = None,
-             sl: Optional[float] = None,
-             tp: Optional[float] = None,
-             tag: object = None) -> 'Order':
-        """
-        Place a new short order and return it. For explanation of parameters, see `Order`
-        and its properties.
-
-        .. caution::
-            Keep in mind that `self.sell(size=.1)` doesn't close existing `self.buy(size=.1)`
-            trade unless:
-
-            * the backtest was run with `exclusive_orders=True`,
-            * the underlying asset price is equal in both cases and
-              the backtest was run with `spread = commission = 0`.
-
-            Use `Trade.close()` or `Position.close()` to explicitly exit trades.
-
-        See also `Strategy.buy()`.
-
-        .. note::
-            If you merely want to close an existing long position,
-            use `Position.close()` or `Trade.close()`.
-        """
-        assert 0 < size < 1 or round(size) == size >= 1, \
-            "size must be a positive fraction of equity, or a positive whole number of units"
-        return self._broker.new_order(-size, limit, stop, sl, tp, tag)
-
-    @property
-    def equity(self) -> float:
-        """Current account equity (cash plus assets)."""
-        return self._broker.equity
-
-    @property
-    def data(self) -> _Data:
-        """
-        Price data, roughly as passed into
-        `backtesting.backtesting.Backtest.__init__`,
-        but with two significant exceptions:
-
-        * `data` is _not_ a DataFrame, but a custom structure
-          that serves customized numpy arrays for reasons of performance
-          and convenience. Besides OHLCV columns, `.index` and length,
-          it offers `.pip` property, the smallest price unit of change.
-        * Within `backtesting.backtesting.Strategy.init`, `data` arrays
-          are available in full length, as passed into
-          `backtesting.backtesting.Backtest.__init__`
-          (for precomputing indicators and such). However, within
-          `backtesting.backtesting.Strategy.next`, `data` arrays are
-          only as long as the current iteration, simulating gradual
-          price point revelation. In each call of
-          `backtesting.backtesting.Strategy.next` (iteratively called by
-          `backtesting.backtesting.Backtest` internally),
-          the last array value (e.g. `data.Close[-1]`)
-          is always the _most recent_ value.
-        * If you need data arrays (e.g. `data.Close`) to be indexed
-          **Pandas series**, you can call their `.s` accessor
-          (e.g. `data.Close.s`). If you need the whole of data
-          as a **DataFrame**, use `.df` accessor (i.e. `data.df`).
-        """
-        return self._data
-
-    @property
-    def position(self) -> 'Position':
-        """Instance of `backtesting.backtesting.Position`."""
-        return self._broker.position
-
-    @property
-    def orders(self) -> 'Tuple[Order, ...]':
-        """List of orders (see `Order`) waiting for execution."""
-        return _Orders(self._broker.orders)
-
-    @property
-    def trades(self) -> 'Tuple[Trade, ...]':
-        """List of active trades (see `Trade`)."""
-        return tuple(self._broker.trades)
-
-    @property
-    def closed_trades(self) -> 'Tuple[Trade, ...]':
-        """List of settled trades (see `Trade`)."""
-        return tuple(self._broker.closed_trades)
-
-
-class _Orders(tuple):
-    """
-    TODO: remove this class. Only for deprecation.
-    """
-    def cancel(self):
-        """Cancel all non-contingent (i.e. SL/TP) orders."""
-        for order in self:
-            if not order.is_contingent:
-                order.cancel()
-
-    def __getattr__(self, item):
-        # TODO: Warn on deprecations from the previous version. Remove in the next.
-        removed_attrs = ('entry', 'set_entry', 'is_long', 'is_short',
-                         'sl', 'tp', 'set_sl', 'set_tp')
-        if item in removed_attrs:
-            raise AttributeError(f'Strategy.orders.{"/.".join(removed_attrs)} were removed in'
-                                 'Backtesting 0.2.0. '
-                                 'Use `Order` API instead. See docs.')
-        raise AttributeError(f"'tuple' object has no attribute {item!r}")
-
-
-class Position:
-    """
-    Currently held asset position, available as
-    `backtesting.backtesting.Strategy.position` within
-    `backtesting.backtesting.Strategy.next`.
-    Can be used in boolean contexts, e.g.
-
-        if self.position:
-            ...  # we have a position, either long or short
-    """
-    def __init__(self, broker: '_Broker'):
-        self.__broker = broker
-
-    def __bool__(self):
-        return self.size != 0
-
-    @property
-    def size(self) -> float:
-        """Position size in units of asset. Negative if position is short."""
-        return sum(trade.size for trade in self.__broker.trades)
-
-    @property
-    def pl(self) -> float:
-        """Profit (positive) or loss (negative) of the current position in cash units."""
-        return sum(trade.pl for trade in self.__broker.trades)
-
-    @property
-    def pl_pct(self) -> float:
-        """Profit (positive) or loss (negative) of the current position in percent."""
-        total_invested = sum(trade.entry_price * abs(trade.size) for trade in self.__broker.trades)
-        return (self.pl / total_invested) * 100 if total_invested else 0
-
-    @property
-    def is_long(self) -> bool:
-        """True if the position is long (position size is positive)."""
-        return self.size > 0
-
-    @property
-    def is_short(self) -> bool:
-        """True if the position is short (position size is negative)."""
-        return self.size < 0
-
-    def close(self, portion: float = 1.):
-        """
-        Close portion of position by closing `portion` of each active trade. See `Trade.close`.
-        """
-        for trade in self.__broker.trades:
-            trade.close(portion)
-
-    def __repr__(self):
-        return f'<Position: {self.size} ({len(self.__broker.trades)} trades)>'
-
-
-class _OutOfMoneyError(Exception):
-    pass
-
-
-class Order:
-    """
-    Place new orders through `Strategy.buy()` and `Strategy.sell()`.
-    Query existing orders through `Strategy.orders`.
-
-    When an order is executed or [filled], it results in a `Trade`.
-
-    If you wish to modify aspects of a placed but not yet filled order,
-    cancel it and place a new one instead.
-
-    All placed orders are [Good 'Til Canceled].
-
-    [filled]: https://www.investopedia.com/terms/f/fill.asp
-    [Good 'Til Canceled]: https://www.investopedia.com/terms/g/gtc.asp
-    """
-    def __init__(self, broker: '_Broker',
-                 size: float,
-                 limit_price: Optional[float] = None,
-                 stop_price: Optional[float] = None,
-                 sl_price: Optional[float] = None,
-                 tp_price: Optional[float] = None,
-                 parent_trade: Optional['Trade'] = None,
-                 tag: object = None):
-        self.__broker = broker
-        assert size != 0
-        self.__size = size
-        self.__limit_price = limit_price
-        self.__stop_price = stop_price
-        self.__sl_price = sl_price
-        self.__tp_price = tp_price
-        self.__parent_trade = parent_trade
-        self.__tag = tag
-
-    def _replace(self, **kwargs):
-        for k, v in kwargs.items():
-            setattr(self, f'_{self.__class__.__qualname__}__{k}', v)
-        return self
-
-    def __repr__(self):
-        return '<Order {}>'.format(', '.join(f'{param}={try_(lambda: round(value, 5), value)!r}'
-                                             for param, value in (
-                                                 ('size', self.__size),
-                                                 ('limit', self.__limit_price),
-                                                 ('stop', self.__stop_price),
-                                                 ('sl', self.__sl_price),
-                                                 ('tp', self.__tp_price),
-                                                 ('contingent', self.is_contingent),
-                                                 ('tag', self.__tag),
-                                             ) if value is not None))  # noqa: E126
-
-    def cancel(self):
-        """Cancel the order."""
-        self.__broker.orders.remove(self)
-        trade = self.__parent_trade
-        if trade:
-            if self is trade._sl_order:
-                trade._replace(sl_order=None)
-            elif self is trade._tp_order:
-                trade._replace(tp_order=None)
-            else:
-                pass  # Order placed by Trade.close()
-
-    # Fields getters
-
-    @property
-    def size(self) -> float:
-        """
-        Order size (negative for short orders).
-
-        If size is a value between 0 and 1, it is interpreted as a fraction of current
-        available liquidity (cash plus `Position.pl` minus used margin).
-        A value greater than or equal to 1 indicates an absolute number of units.
-        """
-        return self.__size
-
-    @property
-    def limit(self) -> Optional[float]:
-        """
-        Order limit price for [limit orders], or None for [market orders],
-        which are filled at next available price.
-
-        [limit orders]: https://www.investopedia.com/terms/l/limitorder.asp
-        [market orders]: https://www.investopedia.com/terms/m/marketorder.asp
-        """
-        return self.__limit_price
-
-    @property
-    def stop(self) -> Optional[float]:
-        """
-        Order stop price for [stop-limit/stop-market][_] order,
-        otherwise None if no stop was set, or the stop price has already been hit.
-
-        [_]: https://www.investopedia.com/terms/s/stoporder.asp
-        """
-        return self.__stop_price
-
-    @property
-    def sl(self) -> Optional[float]:
-        """
-        A stop-loss price at which, if set, a new contingent stop-market order
-        will be placed upon the `Trade` following this order's execution.
-        See also `Trade.sl`.
-        """
-        return self.__sl_price
-
-    @property
-    def tp(self) -> Optional[float]:
-        """
-        A take-profit price at which, if set, a new contingent limit order
-        will be placed upon the `Trade` following this order's execution.
-        See also `Trade.tp`.
-        """
-        return self.__tp_price
-
-    @property
-    def parent_trade(self):
-        return self.__parent_trade
-
-    @property
-    def tag(self):
-        """
-        Arbitrary value (such as a string) which, if set, enables tracking
-        of this order and the associated `Trade` (see `Trade.tag`).
-        """
-        return self.__tag
-
-    __pdoc__['Order.parent_trade'] = False
-
-    # Extra properties
-
-    @property
-    def is_long(self):
-        """True if the order is long (order size is positive)."""
-        return self.__size > 0
-
-    @property
-    def is_short(self):
-        """True if the order is short (order size is negative)."""
-        return self.__size < 0
-
-    @property
-    def is_contingent(self):
-        """
-        True for [contingent] orders, i.e. [OCO] stop-loss and take-profit bracket orders
-        placed upon an active trade. Remaining contingent orders are canceled when
-        their parent `Trade` is closed.
-
-        You can modify contingent orders through `Trade.sl` and `Trade.tp`.
-
-        [contingent]: https://www.investopedia.com/terms/c/contingentorder.asp
-        [OCO]: https://www.investopedia.com/terms/o/oco.asp
-        """
-        return bool((parent := self.__parent_trade) and
-                    (self is parent._sl_order or
-                     self is parent._tp_order))
-
-
-class Trade:
-    """
-    When an `Order` is filled, it results in an active `Trade`.
-    Find active trades in `Strategy.trades` and closed, settled trades in `Strategy.closed_trades`.
-    """
-    def __init__(self, broker: '_Broker', size: int, entry_price: float, entry_bar, tag):
-        self.__broker = broker
-        self.__size = size
-        self.__entry_price = entry_price
-        self.__exit_price: Optional[float] = None
-        self.__entry_bar: int = entry_bar
-        self.__exit_bar: Optional[int] = None
-        self.__sl_order: Optional[Order] = None
-        self.__tp_order: Optional[Order] = None
-        self.__tag = tag
-        self._commissions = 0
-
-    def __repr__(self):
-        return f'<Trade size={self.__size} time={self.__entry_bar}-{self.__exit_bar or ""} ' \
-               f'price={self.__entry_price}-{self.__exit_price or ""} pl={self.pl:.0f}' \
-               f'{" tag=" + str(self.__tag) if self.__tag is not None else ""}>'
-
-    def _replace(self, **kwargs):
-        for k, v in kwargs.items():
-            setattr(self, f'_{self.__class__.__qualname__}__{k}', v)
-        return self
-
-    def _copy(self, **kwargs):
-        return copy(self)._replace(**kwargs)
-
-    def close(self, portion: float = 1.):
-        """Place new `Order` to close `portion` of the trade at next market price."""
-        assert 0 < portion <= 1, "portion must be a fraction between 0 and 1"
-        # Ensure size is an int to avoid rounding errors on 32-bit OS
-        size = copysign(max(1, int(round(abs(self.__size) * portion))), -self.__size)
-        order = Order(self.__broker, size, parent_trade=self, tag=self.__tag)
-        self.__broker.orders.insert(0, order)
-
-    # Fields getters
-
-    @property
-    def size(self):
-        """Trade size (volume; negative for short trades)."""
-        return self.__size
-
-    @property
-    def entry_price(self) -> float:
-        """Trade entry price."""
-        return self.__entry_price
-
-    @property
-    def exit_price(self) -> Optional[float]:
-        """Trade exit price (or None if the trade is still active)."""
-        return self.__exit_price
-
-    @property
-    def entry_bar(self) -> int:
-        """Candlestick bar index of when the trade was entered."""
-        return self.__entry_bar
-
-    @property
-    def exit_bar(self) -> Optional[int]:
-        """
-        Candlestick bar index of when the trade was exited
-        (or None if the trade is still active).
-        """
-        return self.__exit_bar
-
-    @property
-    def tag(self):
-        """
-        A tag value inherited from the `Order` that opened
-        this trade.
-
-        This can be used to track trades and apply conditional
-        logic / subgroup analysis.
-
-        See also `Order.tag`.
-        """
-        return self.__tag
-
-    @property
-    def _sl_order(self):
-        return self.__sl_order
-
-    @property
-    def _tp_order(self):
-        return self.__tp_order
-
-    # Extra properties
-
-    @property
-    def entry_time(self) -> Union[pd.Timestamp, int]:
-        """Datetime of when the trade was entered."""
-        return self.__broker._data.index[self.__entry_bar]
-
-    @property
-    def exit_time(self) -> Optional[Union[pd.Timestamp, int]]:
-        """Datetime of when the trade was exited."""
-        if self.__exit_bar is None:
-            return None
-        return self.__broker._data.index[self.__exit_bar]
-
-    @property
-    def is_long(self):
-        """True if the trade is long (trade size is positive)."""
-        return self.__size > 0
-
-    @property
-    def is_short(self):
-        """True if the trade is short (trade size is negative)."""
-        return not self.is_long
-
-    @property
-    def pl(self):
-        """
-        Trade profit (positive) or loss (negative) in cash units.
-        Commissions are reflected only after the Trade is closed.
-        """
-        price = self.__exit_price or self.__broker.last_price
-        return (self.__size * (price - self.__entry_price)) - self._commissions
-
-    @property
-    def pl_pct(self):
-        """Trade profit (positive) or loss (negative) in percent."""
-        price = self.__exit_price or self.__broker.last_price
-        gross_pl_pct = copysign(1, self.__size) * (price / self.__entry_price - 1)
-
-        # Total commission across the entire trade size to individual units
-        commission_pct = self._commissions / (abs(self.__size) * self.__entry_price)
-        return gross_pl_pct - commission_pct
-
-    @property
-    def value(self):
-        """Trade total value in cash (volume × price)."""
-        price = self.__exit_price or self.__broker.last_price
-        return abs(self.__size) * price
-
-    # SL/TP management API
-
-    @property
-    def sl(self):
-        """
-        Stop-loss price at which to close the trade.
-
-        This variable is writable. By assigning it a new price value,
-        you create or modify the existing SL order.
-        By assigning it `None`, you cancel it.
-        """
-        return self.__sl_order and self.__sl_order.stop
-
-    @sl.setter
-    def sl(self, price: float):
-        self.__set_contingent('sl', price)
-
-    @property
-    def tp(self):
-        """
-        Take-profit price at which to close the trade.
-
-        This property is writable. By assigning it a new price value,
-        you create or modify the existing TP order.
-        By assigning it `None`, you cancel it.
-        """
-        return self.__tp_order and self.__tp_order.limit
-
-    @tp.setter
-    def tp(self, price: float):
-        self.__set_contingent('tp', price)
-
-    def __set_contingent(self, type, price):
-        assert type in ('sl', 'tp')
-        assert price is None or 0 < price < np.inf, f'Make sure 0 < price < inf! price: {price}'
-        attr = f'_{self.__class__.__qualname__}__{type}_order'
-        order: Order = getattr(self, attr)
-        if order:
-            order.cancel()
-        if price:
-            kwargs = {'stop': price} if type == 'sl' else {'limit': price}
-            order = self.__broker.new_order(-self.size, trade=self, tag=self.tag, **kwargs)
-            setattr(self, attr, order)
-
-
-class _Broker:
-    def __init__(self, *, data, cash, spread, commission, margin,
-                 trade_on_close, hedging, exclusive_orders, index):
-        assert cash > 0, f"cash should be > 0, is {cash}"
-        assert 0 < margin <= 1, f"margin should be between 0 and 1, is {margin}"
-        self._data: _Data = data
-        self._cash = cash
-
-        if callable(commission):
-            self._commission = commission
-        else:
-            try:
-                self._commission_fixed, self._commission_relative = commission
-            except TypeError:
-                self._commission_fixed, self._commission_relative = 0, commission
-            assert self._commission_fixed >= 0, 'Need fixed cash commission in $ >= 0'
-            assert -.1 <= self._commission_relative < .1, \
-                ("commission should be between -10% "
-                 f"(e.g. market-maker's rebates) and 10% (fees), is {self._commission_relative}")
-            self._commission = self._commission_func
-
-        self._spread = spread
-        self._leverage = 1 / margin
-        self._trade_on_close = trade_on_close
-        self._hedging = hedging
-        self._exclusive_orders = exclusive_orders
-
-        self._equity = np.tile(np.nan, len(index))
-        self.orders: List[Order] = []
-        self.trades: List[Trade] = []
-        self.position = Position(self)
-        self.closed_trades: List[Trade] = []
-
-    def _commission_func(self, order_size, price):
-        return self._commission_fixed + abs(order_size) * price * self._commission_relative
-
-    def __repr__(self):
-        return f'<Broker: {self._cash:.0f}{self.position.pl:+.1f} ({len(self.trades)} trades)>'
-
-    def new_order(self,
-                  size: float,
-                  limit: Optional[float] = None,
-                  stop: Optional[float] = None,
-                  sl: Optional[float] = None,
-                  tp: Optional[float] = None,
-                  tag: object = None,
-                  *,
-                  trade: Optional[Trade] = None) -> Order:
-        """
-        Argument size indicates whether the order is long or short
-        """
-        size = float(size)
-        stop = stop and float(stop)
-        limit = limit and float(limit)
-        sl = sl and float(sl)
-        tp = tp and float(tp)
-
-        is_long = size > 0
-        assert size != 0, size
-        adjusted_price = self._adjusted_price(size)
-
-        if is_long:
-            if not (sl or -np.inf) < (limit or stop or adjusted_price) < (tp or np.inf):
-                raise ValueError(
-                    "Long orders require: "
-                    f"SL ({sl}) < LIMIT ({limit or stop or adjusted_price}) < TP ({tp})")
-        else:
-            if not (tp or -np.inf) < (limit or stop or adjusted_price) < (sl or np.inf):
-                raise ValueError(
-                    "Short orders require: "
-                    f"TP ({tp}) < LIMIT ({limit or stop or adjusted_price}) < SL ({sl})")
-
-        order = Order(self, size, limit, stop, sl, tp, trade, tag)
-
-        if not trade:
-            # If exclusive orders (each new order auto-closes previous orders/position),
-            # cancel all non-contingent orders and close all open trades beforehand
-            if self._exclusive_orders:
-                for o in self.orders:
-                    if not o.is_contingent:
-                        o.cancel()
-                for t in self.trades:
-                    t.close()
-
-        # Put the new order in the order queue, Ensure SL orders are processed first
-        self.orders.insert(0 if trade and stop else len(self.orders), order)
-
-        return order
-
-    @property
-    def last_price(self) -> float:
-        """ Price at the last (current) close. """
-        return self._data.Close[-1]
-
-    def _adjusted_price(self, size=None, price=None) -> float:
-        """
-        Long/short `price`, adjusted for spread.
-        In long positions, the adjusted price is a fraction higher, and vice versa.
-        """
-        return (price or self.last_price) * (1 + copysign(self._spread, size))
-
-    @property
-    def equity(self) -> float:
-        return self._cash + sum(trade.pl for trade in self.trades)
-
-    @property
-    def margin_available(self) -> float:
-        # From https://github.com/QuantConnect/Lean/pull/3768
-        margin_used = sum(trade.value / self._leverage for trade in self.trades)
-        return max(0, self.equity - margin_used)
-
-    def next(self):
-        i = self._i = len(self._data) - 1
-        self._process_orders()
-
-        # Log account equity for the equity curve
-        equity = self.equity
-        self._equity[i] = equity
-
-        # If equity is negative, set all to 0 and stop the simulation
-        if equity <= 0:
-            assert self.margin_available <= 0
-            for trade in self.trades:
-                self._close_trade(trade, self._data.Close[-1], i)
-            self._cash = 0
-            self._equity[i:] = 0
-            raise _OutOfMoneyError
-
-    def _process_orders(self):
-        data = self._data
-        open, high, low = data.Open[-1], data.High[-1], data.Low[-1]
-        reprocess_orders = False
-
-        # Process orders
-        for order in list(self.orders):  # type: Order
-
-            # Related SL/TP order was already removed
-            if order not in self.orders:
-                continue
-
-            # Check if stop condition was hit
-            stop_price = order.stop
-            if stop_price:
-                is_stop_hit = ((high >= stop_price) if order.is_long else (low <= stop_price))
-                if not is_stop_hit:
-                    continue
-
-                # > When the stop price is reached, a stop order becomes a market/limit order.
-                # https://www.sec.gov/fast-answers/answersstopordhtm.html
-                order._replace(stop_price=None)
-
-            # Determine purchase price.
-            # Check if limit order can be filled.
-            if order.limit:
-                is_limit_hit = low <= order.limit if order.is_long else high >= order.limit
-                # When stop and limit are hit within the same bar, we pessimistically
-                # assume limit was hit before the stop (i.e. "before it counts")
-                is_limit_hit_before_stop = (is_limit_hit and
-                                            (order.limit <= (stop_price or -np.inf)
-                                             if order.is_long
-                                             else order.limit >= (stop_price or np.inf)))
-                if not is_limit_hit or is_limit_hit_before_stop:
-                    continue
-
-                # stop_price, if set, was hit within this bar
-                price = (min(stop_price or open, order.limit)
-                         if order.is_long else
-                         max(stop_price or open, order.limit))
-            else:
-                # Market-if-touched / market order
-                # Contingent orders always on next open
-                prev_close = data.Close[-2]
-                price = prev_close if self._trade_on_close and not order.is_contingent else open
-                if stop_price:
-                    price = max(price, stop_price) if order.is_long else min(price, stop_price)
-
-            # Determine entry/exit bar index
-            is_market_order = not order.limit and not stop_price
-            time_index = (
-                (self._i - 1)
-                if is_market_order and self._trade_on_close and not order.is_contingent else
-                self._i)
-
-            # If order is a SL/TP order, it should close an existing trade it was contingent upon
-            if order.parent_trade:
-                trade = order.parent_trade
-                _prev_size = trade.size
-                # If order.size is "greater" than trade.size, this order is a trade.close()
-                # order and part of the trade was already closed beforehand
-                size = copysign(min(abs(_prev_size), abs(order.size)), order.size)
-                # If this trade isn't already closed (e.g. on multiple `trade.close(.5)` calls)
-                if trade in self.trades:
-                    self._reduce_trade(trade, price, size, time_index)
-                    assert order.size != -_prev_size or trade not in self.trades
-                    if price == stop_price:
-                        # Set SL back on the order for stats._trades["SL"]
-                        trade._sl_order._replace(stop_price=stop_price)
-                if order in (trade._sl_order,
-                             trade._tp_order):
-                    assert order.size == -trade.size
-                    assert order not in self.orders  # Removed when trade was closed
-                else:
-                    # It's a trade.close() order, now done
-                    assert abs(_prev_size) >= abs(size) >= 1
-                    self.orders.remove(order)
-                continue
-
-            # Else this is a stand-alone trade
-
-            # Adjust price to include commission (or bid-ask spread).
-            # In long positions, the adjusted price is a fraction higher, and vice versa.
-            adjusted_price = self._adjusted_price(order.size, price)
-            adjusted_price_plus_commission = \
-                adjusted_price + self._commission(order.size, price) / abs(order.size)
-
-            # If order size was specified proportionally,
-            # precompute true size in units, accounting for margin and spread/commissions
-            size = order.size
-            if -1 < size < 1:
-                size = copysign(int((self.margin_available * self._leverage * abs(size))
-                                    // adjusted_price_plus_commission), size)
-                # Not enough cash/margin even for a single unit
-                if not size:
-                    warnings.warn(
-                        f'time={self._i}: Broker canceled the relative-sized '
-                        f'order due to insufficient margin.', category=UserWarning)
-                    # XXX: The order is canceled by the broker?
-                    self.orders.remove(order)
-                    continue
-            assert size == round(size)
-            need_size = int(size)
-
-            if not self._hedging:
-                # Fill position by FIFO closing/reducing existing opposite-facing trades.
-                # Existing trades are closed at unadjusted price, because the adjustment
-                # was already made when buying.
-                for trade in list(self.trades):
-                    if trade.is_long == order.is_long:
-                        continue
-                    assert trade.size * order.size < 0
-
-                    # Order size greater than this opposite-directed existing trade,
-                    # so it will be closed completely
-                    if abs(need_size) >= abs(trade.size):
-                        self._close_trade(trade, price, time_index)
-                        need_size += trade.size
-                    else:
-                        # The existing trade is larger than the new order,
-                        # so it will only be closed partially
-                        self._reduce_trade(trade, price, need_size, time_index)
-                        need_size = 0
-
-                    if not need_size:
-                        break
-
-            # If we don't have enough liquidity to cover for the order, the broker CANCELS it
-            if abs(need_size) * adjusted_price_plus_commission > \
-                    self.margin_available * self._leverage:
-                self.orders.remove(order)
-                continue
-
-            # Open a new trade
-            if need_size:
-                self._open_trade(adjusted_price,
-                                 need_size,
-                                 order.sl,
-                                 order.tp,
-                                 time_index,
-                                 order.tag)
-
-                # We need to reprocess the SL/TP orders newly added to the queue.
-                # This allows e.g. SL hitting in the same bar the order was open.
-                # See https://github.com/kernc/backtesting.py/issues/119
-                if order.sl or order.tp:
-                    if is_market_order:
-                        reprocess_orders = True
-                    # Order.stop and TP hit within the same bar, but SL wasn't. This case
-                    # is not ambiguous, because stop and TP go in the same price direction.
-                    elif stop_price and not order.limit and order.tp and (
-                            (order.is_long and order.tp <= high and (order.sl or -np.inf) < low) or
-                            (order.is_short and order.tp >= low and (order.sl or np.inf) > high)):
-                        reprocess_orders = True
-                    elif (low <= (order.sl or -np.inf) <= high or
-                          low <= (order.tp or -np.inf) <= high):
-                        warnings.warn(
-                            f"({data.index[-1]}) A contingent SL/TP order would execute in the "
-                            "same bar its parent stop/limit order was turned into a trade. "
-                            "Since we can't assert the precise intra-candle "
-                            "price movement, the affected SL/TP order will instead be executed on "
-                            "the next (matching) price/bar, making the result (of this trade) "
-                            "somewhat dubious. "
-                            "See https://github.com/kernc/backtesting.py/issues/119",
-                            UserWarning)
-
-            # Order processed
-            self.orders.remove(order)
-
-        if reprocess_orders:
-            self._process_orders()
-
-    def _reduce_trade(self, trade: Trade, price: float, size: float, time_index: int):
-        assert trade.size * size < 0
-        assert abs(trade.size) >= abs(size)
-
-        size_left = trade.size + size
-        assert size_left * trade.size >= 0
-        if not size_left:
-            close_trade = trade
-        else:
-            # Reduce existing trade ...
-            trade._replace(size=size_left)
-            if trade._sl_order:
-                trade._sl_order._replace(size=-trade.size)
-            if trade._tp_order:
-                trade._tp_order._replace(size=-trade.size)
-
-            # ... by closing a reduced copy of it
-            close_trade = trade._copy(size=-size, sl_order=None, tp_order=None)
-            self.trades.append(close_trade)
-
-        self._close_trade(close_trade, price, time_index)
-
-    def _close_trade(self, trade: Trade, price: float, time_index: int):
-        self.trades.remove(trade)
-        if trade._sl_order:
-            self.orders.remove(trade._sl_order)
-        if trade._tp_order:
-            self.orders.remove(trade._tp_order)
-
-        closed_trade = trade._replace(exit_price=price, exit_bar=time_index)
-        self.closed_trades.append(closed_trade)
-        # Apply commission one more time at trade exit
-        commission = self._commission(trade.size, price)
-        self._cash += trade.pl - commission
-        # Save commissions on Trade instance for stats
-        trade_open_commission = self._commission(closed_trade.size, closed_trade.entry_price)
-        # applied here instead of on Trade open because size could have changed
-        # by way of _reduce_trade()
-        closed_trade._commissions = commission + trade_open_commission
-
-    def _open_trade(self, price: float, size: int,
-                    sl: Optional[float], tp: Optional[float], time_index: int, tag):
-        trade = Trade(self, size, price, time_index, tag)
-        self.trades.append(trade)
-        # Apply broker commission at trade open
-        self._cash -= self._commission(size, price)
-        # Create SL/TP (bracket) orders.
-        if tp:
-            trade.tp = tp
-        if sl:
-            trade.sl = sl
-
-
-class Backtest:
-    """
-    Backtest a particular (parameterized) strategy
-    on particular data.
-
-    Initialize a backtest. Requires data and a strategy to test.
-    After initialization, you can call method
-    `backtesting.backtesting.Backtest.run` to run a backtest
-    instance, or `backtesting.backtesting.Backtest.optimize` to
-    optimize it.
-
-    `data` is a `pd.DataFrame` with columns:
-    `Open`, `High`, `Low`, `Close`, and (optionally) `Volume`.
-    If any columns are missing, set them to what you have available,
-    e.g.
-
-        df['Open'] = df['High'] = df['Low'] = df['Close']
-
-    The passed data frame can contain additional columns that
-    can be used by the strategy (e.g. sentiment info).
-    DataFrame index can be either a datetime index (timestamps)
-    or a monotonic range index (i.e. a sequence of periods).
-
-    `strategy` is a `backtesting.backtesting.Strategy`
-    _subclass_ (not an instance).
-
-    `cash` is the initial cash to start with.
-
-    `spread` is the the constant bid-ask spread rate (relative to the price).
-    E.g. set it to `0.0002` for commission-less forex
-    trading where the average spread is roughly 0.2‰ of the asking price.
-
-    `commission` is the commission rate. E.g. if your broker's commission
-    is 1% of order value, set commission to `0.01`.
-    The commission is applied twice: at trade entry and at trade exit.
-    Besides one single floating value, `commission` can also be a tuple of floating
-    values `(fixed, relative)`. E.g. set it to `(100, .01)`
-    if your broker charges minimum $100 + 1%.
-    Additionally, `commission` can be a callable
-    `func(order_size: int, price: float) -> float`
-    (note, order size is negative for short orders),
-    which can be used to model more complex commission structures.
-    Negative commission values are interpreted as market-maker's rebates.
-
-    .. note::
-        Before v0.4.0, the commission was only applied once, like `spread` is now.
-        If you want to keep the old behavior, simply set `spread` instead.
-
-    .. note::
-        With nonzero `commission`, long and short orders will be placed
-        at an adjusted price that is slightly higher or lower (respectively)
-        than the current price. See e.g.
-        [#153](https://github.com/kernc/backtesting.py/issues/153),
-        [#538](https://github.com/kernc/backtesting.py/issues/538),
-        [#633](https://github.com/kernc/backtesting.py/issues/633).
-
-    `margin` is the required margin (ratio) of a leveraged account.
-    No difference is made between initial and maintenance margins.
-    To run the backtest using e.g. 50:1 leverge that your broker allows,
-    set margin to `0.02` (1 / leverage).
-
-    If `trade_on_close` is `True`, market orders will be filled
-    with respect to the current bar's closing price instead of the
-    next bar's open.
-
-    If `hedging` is `True`, allow trades in both directions simultaneously.
-    If `False`, the opposite-facing orders first close existing trades in
-    a [FIFO] manner.
-
-    If `exclusive_orders` is `True`, each new order auto-closes the previous
-    trade/position, making at most a single trade (long or short) in effect
-    at each time.
-
-    If `finalize_trades` is `True`, the trades that are still
-    [active and ongoing] at the end of the backtest will be closed on
-    the last bar and will contribute to the computed backtest statistics.
-
-    .. tip:: Fractional trading
-        See also `backtesting.lib.FractionalBacktest` if you want to trade
-        fractional units (of e.g. bitcoin).
-
-    [FIFO]: https://www.investopedia.com/terms/n/nfa-compliance-rule-2-43b.asp
-    [active and ongoing]: https://kernc.github.io/backtesting.py/doc/backtesting/backtesting.html#backtesting.backtesting.Strategy.trades
-    """  # noqa: E501
-    def __init__(self,
-                 data: pd.DataFrame,
-                 strategy: Type[Strategy],
-                 *,
-                 cash: float = 10_000,
-                 spread: float = .0,
-                 commission: Union[float, Tuple[float, float]] = .0,
-                 margin: float = 1.,
-                 trade_on_close=False,
-                 hedging=False,
-                 exclusive_orders=False,
-                 finalize_trades=False,
-                 ):
-        if not (isinstance(strategy, type) and issubclass(strategy, Strategy)):
-            raise TypeError('`strategy` must be a Strategy sub-type')
-        if not isinstance(data, pd.DataFrame):
-            raise TypeError("`data` must be a pandas.DataFrame with columns")
-        if not isinstance(spread, Number):
-            raise TypeError('`spread` must be a float value, percent of '
-                            'entry order price')
-        if not isinstance(commission, (Number, tuple)) and not callable(commission):
-            raise TypeError('`commission` must be a float percent of order value, '
-                            'a tuple of `(fixed, relative)` commission, '
-                            'or a function that takes `(order_size, price)`'
-                            'and returns commission dollar value')
-
-        data = data.copy(deep=False)
-
-        # Convert index to datetime index
-        if (not isinstance(data.index, pd.DatetimeIndex) and
-            not isinstance(data.index, pd.RangeIndex) and
-            # Numeric index with most large numbers
-            (data.index.is_numeric() and
-             (data.index > pd.Timestamp('1975').timestamp()).mean() > .8)):
-            try:
-                data.index = pd.to_datetime(data.index, infer_datetime_format=True)
-            except ValueError:
-                pass
-
-        if 'Volume' not in data:
-            data['Volume'] = np.nan
-
-        if len(data) == 0:
-            raise ValueError('OHLC `data` is empty')
-        if len(data.columns.intersection({'Open', 'High', 'Low', 'Close', 'Volume'})) != 5:
-            raise ValueError("`data` must be a pandas.DataFrame with columns "
-                             "'Open', 'High', 'Low', 'Close', and (optionally) 'Volume'")
-        if data[['Open', 'High', 'Low', 'Close']].isnull().values.any():
-            raise ValueError('Some OHLC values are missing (NaN). '
-                             'Please strip those lines with `df.dropna()` or '
-                             'fill them in with `df.interpolate()` or whatever.')
-        if np.any(data['Close'] > cash):
-            warnings.warn('Some prices are larger than initial cash value. Note that fractional '
-                          'trading is not supported by this class. If you want to trade Bitcoin, '
-                          'increase initial cash, or trade μBTC or satoshis instead (see e.g. class '
-                          '`backtesting.lib.FractionalBacktest`.',
-                          stacklevel=2)
-        if not data.index.is_monotonic_increasing:
-            warnings.warn('Data index is not sorted in ascending order. Sorting.',
-                          stacklevel=2)
-            data = data.sort_index()
-        if not isinstance(data.index, pd.DatetimeIndex):
-            warnings.warn('Data index is not datetime. Assuming simple periods, '
-                          'but `pd.DateTimeIndex` is advised.',
-                          stacklevel=2)
-
-        self._data: pd.DataFrame = data
-        self._broker = partial(
-            _Broker, cash=cash, spread=spread, commission=commission, margin=margin,
-            trade_on_close=trade_on_close, hedging=hedging,
-            exclusive_orders=exclusive_orders, index=data.index,
-        )
-        self._strategy = strategy
-        self._results: Optional[pd.Series] = None
-        self._finalize_trades = bool(finalize_trades)
-
-    def run(self, **kwargs) -> pd.Series:
-        """
-        Run the backtest. Returns `pd.Series` with results and statistics.
-
-        Keyword arguments are interpreted as strategy parameters.
-
-            >>> Backtest(GOOG, SmaCross).run()
-            Start                     2004-08-19 00:00:00
-            End                       2013-03-01 00:00:00
-            Duration                   3116 days 00:00:00
-            Exposure Time [%]                    96.74115
-            Equity Final [$]                     51422.99
-            Equity Peak [$]                      75787.44
-            Return [%]                           414.2299
-            Buy & Hold Return [%]               703.45824
-            Return (Ann.) [%]                    21.18026
-            Volatility (Ann.) [%]                36.49391
-            CAGR [%]                             14.15984
-            Sharpe Ratio                          0.58038
-            Sortino Ratio                         1.08479
-            Calmar Ratio                          0.44144
-            Alpha [%]                           394.37391
-            Beta                                  0.03803
-            Max. Drawdown [%]                   -47.98013
-            Avg. Drawdown [%]                    -5.92585
-            Max. Drawdown Duration      584 days 00:00:00
-            Avg. Drawdown Duration       41 days 00:00:00
-            # Trades                                   66
-            Win Rate [%]                          46.9697
-            Best Trade [%]                       53.59595
-            Worst Trade [%]                     -18.39887
-            Avg. Trade [%]                        2.53172
-            Max. Trade Duration         183 days 00:00:00
-            Avg. Trade Duration          46 days 00:00:00
-            Profit Factor                         2.16795
-            Expectancy [%]                        3.27481
-            SQN                                   1.07662
-            Kelly Criterion                       0.15187
-            _strategy                            SmaCross
-            _equity_curve                           Eq...
-            _trades                       Size  EntryB...
-            dtype: object
-
-        .. warning::
-            You may obtain different results for different strategy parameters.
-            E.g. if you use 50- and 200-bar SMA, the trading simulation will
-            begin on bar 201. The actual length of delay is equal to the lookback
-            period of the `Strategy.I` indicator which lags the most.
-            Obviously, this can affect results.
-        """
-        data = _Data(self._data.copy(deep=False))
-        broker: _Broker = self._broker(data=data)
-        strategy: Strategy = self._strategy(broker, data, kwargs)
-
-        strategy.init()
-        data._update()  # Strategy.init might have changed/added to data.df
-
-        # Indicators used in Strategy.next()
-        indicator_attrs = _strategy_indicators(strategy)
-
-        # Skip first few candles where indicators are still "warming up"
-        # +1 to have at least two entries available
-        start = 1 + _indicator_warmup_nbars(strategy)
-
-        # Disable "invalid value encountered in ..." warnings. Comparison
-        # np.nan >= 3 is not invalid; it's False.
-        with np.errstate(invalid='ignore'):
-
-            for i in _tqdm(range(start, len(self._data)), desc=self.run.__qualname__,
-                           unit='bar', mininterval=2, miniters=100):
-                # Prepare data and indicators for `next` call
-                data._set_length(i + 1)
-                for attr, indicator in indicator_attrs:
-                    # Slice indicator on the last dimension (case of 2d indicator)
-                    setattr(strategy, attr, indicator[..., :i + 1])
-
-                # Handle orders processing and broker stuff
-                try:
-                    broker.next()
-                except _OutOfMoneyError:
-                    break
-
-                # Next tick, a moment before bar close
-                strategy.next()
-            else:
-                if self._finalize_trades is True:
-                    # Close any remaining open trades so they produce some stats
-                    for trade in reversed(broker.trades):
-                        trade.close()
-
-                    # HACK: Re-run broker one last time to handle close orders placed in the last
-                    #  strategy iteration. Use the same OHLC values as in the last broker iteration.
-                    if start < len(self._data):
-                        try_(broker.next, exception=_OutOfMoneyError)
-                elif len(broker.trades):
-                    warnings.warn(
-                        'Some trades remain open at the end of backtest. Use '
-                        '`Backtest(..., finalize_trades=True)` to close them and '
-                        'include them in stats.', stacklevel=2)
-
-            # Set data back to full length
-            # for future `indicator._opts['data'].index` calls to work
-            data._set_length(len(self._data))
-
-            equity = pd.Series(broker._equity).bfill().fillna(broker._cash).values
-            self._results = compute_stats(
-                trades=broker.closed_trades,
-                equity=equity,
-                ohlc_data=self._data,
-                risk_free_rate=0.0,
-                strategy_instance=strategy,
-            )
-
-        return self._results
-
-    def optimize(self, *,
-                 maximize: Union[str, Callable[[pd.Series], float]] = 'SQN',
-                 method: str = 'grid',
-                 max_tries: Optional[Union[int, float]] = None,
-                 constraint: Optional[Callable[[dict], bool]] = None,
-                 return_heatmap: bool = False,
-                 return_optimization: bool = False,
-                 random_state: Optional[int] = None,
-                 **kwargs) -> Union[pd.Series,
-                                    Tuple[pd.Series, pd.Series],
-                                    Tuple[pd.Series, pd.Series, dict]]:
-        """
-        Optimize strategy parameters to an optimal combination.
-        Returns result `pd.Series` of the best run.
-
-        `maximize` is a string key from the
-        `backtesting.backtesting.Backtest.run`-returned results series,
-        or a function that accepts this series object and returns a number;
-        the higher the better. By default, the method maximizes
-        Van Tharp's [System Quality Number](https://google.com/search?q=System+Quality+Number).
-
-        `method` is the optimization method. Currently two methods are supported:
-
-        * `"grid"` which does an exhaustive (or randomized) search over the
-          cartesian product of parameter combinations, and
-        * `"sambo"` which finds close-to-optimal strategy parameters using
-          [model-based optimization], making at most `max_tries` evaluations.
-
-        [model-based optimization]: https://sambo-optimization.github.io
-
-        `max_tries` is the maximal number of strategy runs to perform.
-        If `method="grid"`, this results in randomized grid search.
-        If `max_tries` is a floating value between (0, 1], this sets the
-        number of runs to approximately that fraction of full grid space.
-        Alternatively, if integer, it denotes the absolute maximum number
-        of evaluations. If unspecified (default), grid search is exhaustive,
-        whereas for `method="sambo"`, `max_tries` is set to 200.
-
-        `constraint` is a function that accepts a dict-like object of
-        parameters (with values) and returns `True` when the combination
-        is admissible to test with. By default, any parameters combination
-        is considered admissible.
-
-        If `return_heatmap` is `True`, besides returning the result
-        series, an additional `pd.Series` is returned with a multiindex
-        of all admissible parameter combinations, which can be further
-        inspected or projected onto 2D to plot a heatmap
-        (see `backtesting.lib.plot_heatmaps()`).
-
-        If `return_optimization` is True and `method = 'sambo'`,
-        in addition to result series (and maybe heatmap), return raw
-        [`scipy.optimize.OptimizeResult`][OptimizeResult] for further
-        inspection, e.g. with [SAMBO]'s [plotting tools].
-
-        [OptimizeResult]: https://sambo-optimization.github.io/doc/sambo/#sambo.OptimizeResult
-        [SAMBO]: https://sambo-optimization.github.io
-        [plotting tools]: https://sambo-optimization.github.io/doc/sambo/plot.html
-
-        If you want reproducible optimization results, set `random_state`
-        to a fixed integer random seed.
-
-        Additional keyword arguments represent strategy arguments with
-        list-like collections of possible values. For example, the following
-        code finds and returns the "best" of the 7 admissible (of the
-        9 possible) parameter combinations:
-
-            best_stats = backtest.optimize(sma1=[5, 10, 15], sma2=[10, 20, 40],
-                                           constraint=lambda p: p.sma1 < p.sma2)
-        """
-        if not kwargs:
-            raise ValueError('Need some strategy parameters to optimize')
-
-        maximize_key = None
-        if isinstance(maximize, str):
-            maximize_key = str(maximize)
-            if maximize not in dummy_stats().index:
-                raise ValueError('`maximize`, if str, must match a key in pd.Series '
-                                 'result of backtest.run()')
-
-            def maximize(stats: pd.Series, _key=maximize):
-                return stats[_key]
-
-        elif not callable(maximize):
-            raise TypeError('`maximize` must be str (a field of backtest.run() result '
-                            'Series) or a function that accepts result Series '
-                            'and returns a number; the higher the better')
-        assert callable(maximize), maximize
-
-        have_constraint = bool(constraint)
-        if constraint is None:
-
-            def constraint(_):
-                return True
-
-        elif not callable(constraint):
-            raise TypeError("`constraint` must be a function that accepts a dict "
-                            "of strategy parameters and returns a bool whether "
-                            "the combination of parameters is admissible or not")
-        assert callable(constraint), constraint
-
-        if method == 'skopt':
-            method = 'sambo'
-            warnings.warn('`Backtest.optimize(method="skopt")` is deprecated. Use `method="sambo"`.',
-                          DeprecationWarning, stacklevel=2)
-        if return_optimization and method != 'sambo':
-            raise ValueError("return_optimization=True only valid if method='sambo'")
-
-        def _tuple(x):
-            return x if isinstance(x, Sequence) and not isinstance(x, str) else (x,)
-
-        for k, v in kwargs.items():
-            if len(_tuple(v)) == 0:
-                raise ValueError(f"Optimization variable '{k}' is passed no "
-                                 f"optimization values: {k}={v}")
-
-        class AttrDict(dict):
-            def __getattr__(self, item):
-                return self[item]
-
-        def _grid_size():
-            size = int(np.prod([len(_tuple(v)) for v in kwargs.values()]))
-            if size < 10_000 and have_constraint:
-                size = sum(1 for p in product(*(zip(repeat(k), _tuple(v))
-                                                for k, v in kwargs.items()))
-                           if constraint(AttrDict(p)))
-            return size
-
-        def _optimize_grid() -> Union[pd.Series, Tuple[pd.Series, pd.Series]]:
-            rand = default_rng(random_state).random
-            grid_frac = (1 if max_tries is None else
-                         max_tries if 0 < max_tries <= 1 else
-                         max_tries / _grid_size())
-            param_combos = [dict(params)  # back to dict so it pickles
-                            for params in (AttrDict(params)
-                                           for params in product(*(zip(repeat(k), _tuple(v))
-                                                                   for k, v in kwargs.items())))
-                            if constraint(params)
-                            and rand() <= grid_frac]
-            if not param_combos:
-                raise ValueError('No admissible parameter combinations to test')
-
-            if len(param_combos) > 300:
-                warnings.warn(f'Searching for best of {len(param_combos)} configurations.',
-                              stacklevel=2)
-
-            heatmap = pd.Series(np.nan,
-                                name=maximize_key,
-                                index=pd.MultiIndex.from_tuples(
-                                    [p.values() for p in param_combos],
-                                    names=next(iter(param_combos)).keys()))
-
-            from . import Pool
-            with Pool() as pool, \
-                    SharedMemoryManager() as smm:
-                with patch(self, '_data', None):
-                    bt = copy(self)  # bt._data will be reassigned in _mp_task worker
-                results = _tqdm(
-                    pool.imap(Backtest._mp_task,
-                              ((bt, smm.df2shm(self._data), params_batch)
-                               for params_batch in _batch(param_combos))),
-                    total=len(param_combos),
-                    desc='Backtest.optimize'
-                )
-                for param_batch, result in zip(_batch(param_combos), results):
-                    for params, stats in zip(param_batch, result):
-                        if stats is not None:
-                            heatmap[tuple(params.values())] = maximize(stats)
-
-            if pd.isnull(heatmap).all():
-                # No trade was made in any of the runs. Just make a random
-                # run so we get some, if empty, results
-                stats = self.run(**param_combos[0])
-            else:
-                best_params = heatmap.idxmax(skipna=True)
-                stats = self.run(**dict(zip(heatmap.index.names, best_params)))
-
-            if return_heatmap:
-                return stats, heatmap
-            return stats
-
-        def _optimize_sambo() -> Union[pd.Series,
-                                       Tuple[pd.Series, pd.Series],
-                                       Tuple[pd.Series, pd.Series, dict]]:
-            try:
-                import sambo
-            except ImportError:
-                raise ImportError("Need package 'sambo' for method='sambo'. pip install sambo") from None
-
-            nonlocal max_tries
-            max_tries = (200 if max_tries is None else
-                         max(1, int(max_tries * _grid_size())) if 0 < max_tries <= 1 else
-                         max_tries)
-
-            dimensions = []
-            for key, values in kwargs.items():
-                values = np.asarray(values)
-                if values.dtype.kind in 'mM':  # timedelta, datetime64
-                    # these dtypes are unsupported in SAMBO, so convert to raw int
-                    # TODO: save dtype and convert back later
-                    values = values.astype(np.int64)
-
-                if values.dtype.kind in 'iumM':
-                    dimensions.append((values.min(), values.max() + 1))
-                elif values.dtype.kind == 'f':
-                    dimensions.append((values.min(), values.max()))
-                else:
-                    dimensions.append(values.tolist())
-
-            # Avoid recomputing re-evaluations
-            @lru_cache()
-            def memoized_run(tup):
-                nonlocal maximize, self
-                stats = self.run(**dict(tup))
-                return -maximize(stats)
-
-            progress = iter(_tqdm(repeat(None), total=max_tries, leave=False,
-                                  desc=self.optimize.__qualname__, mininterval=2))
-            _names = tuple(kwargs.keys())
-
-            def objective_function(x):
-                nonlocal progress, memoized_run, constraint, _names
-                next(progress)
-                value = memoized_run(tuple(zip(_names, x)))
-                return 0 if np.isnan(value) else value
-
-            def cons(x):
-                nonlocal constraint, _names
-                return constraint(AttrDict(zip(_names, x)))
-
-            res = sambo.minimize(
-                fun=objective_function,
-                bounds=dimensions,
-                constraints=cons,
-                max_iter=max_tries,
-                method='sceua',
-                rng=random_state)
-
-            stats = self.run(**dict(zip(kwargs.keys(), res.x)))
-            output = [stats]
-
-            if return_heatmap:
-                heatmap = pd.Series(dict(zip(map(tuple, res.xv), -res.funv)),
-                                    name=maximize_key)
-                heatmap.index.names = kwargs.keys()
-                heatmap.sort_index(inplace=True)
-                output.append(heatmap)
-
-            if return_optimization:
-                output.append(res)
-
-            return stats if len(output) == 1 else tuple(output)
-
-        if method == 'grid':
-            output = _optimize_grid()
-        elif method in ('sambo', 'skopt'):
-            output = _optimize_sambo()
-        else:
-            raise ValueError(f"Method should be 'grid' or 'sambo', not {method!r}")
-        return output
-
-    @staticmethod
-    def _mp_task(arg):
-        bt, data_shm, params_batch = arg
-        bt._data, shm = SharedMemoryManager.shm2df(data_shm)
-        try:
-            return [stats.filter(regex='^[^_]') if stats['# Trades'] else None
-                    for stats in (bt.run(**params)
-                                  for params in params_batch)]
-        finally:
-            for shmem in shm:
-                shmem.close()
-
-    def plot(self, *, results: pd.Series = None, filename=None, 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: Union[bool, str] = True,
-             resample=True, reverse_indicators=False,
-             show_legend=True, open_browser=True):
-        """
-        Plot the progression of the last backtest run.
-
-        If `results` is provided, it should be a particular result
-        `pd.Series` such as returned by
-        `backtesting.backtesting.Backtest.run` or
-        `backtesting.backtesting.Backtest.optimize`, otherwise the last
-        run's results are used.
-
-        `filename` is the path to save the interactive HTML plot to.
-        By default, a strategy/parameter-dependent file is created in the
-        current working directory.
-
-        `plot_width` is the width of the plot in pixels. If None (default),
-        the plot is made to span 100% of browser width. The height is
-        currently non-adjustable.
-
-        If `plot_equity` is `True`, the resulting plot will contain
-        an equity (initial cash plus assets) graph section. This is the same
-        as `plot_return` plus initial 100%.
-
-        If `plot_return` is `True`, the resulting plot will contain
-        a cumulative return graph section. This is the same
-        as `plot_equity` minus initial 100%.
-
-        If `plot_pl` is `True`, the resulting plot will contain
-        a profit/loss (P/L) indicator section.
-
-        If `plot_volume` is `True`, the resulting plot will contain
-        a trade volume section.
-
-        If `plot_drawdown` is `True`, the resulting plot will contain
-        a separate drawdown graph section.
-
-        If `plot_trades` is `True`, the stretches between trade entries
-        and trade exits are marked by hash-marked tractor beams.
-
-        If `smooth_equity` is `True`, the equity graph will be
-        interpolated between fixed points at trade closing times,
-        unaffected by any interim asset volatility.
-
-        If `relative_equity` is `True`, scale and label equity graph axis
-        with return percent, not absolute cash-equivalent values.
-
-        If `superimpose` is `True`, superimpose larger-timeframe candlesticks
-        over the original candlestick chart. Default downsampling rule is:
-        monthly for daily data, daily for hourly data, hourly for minute data,
-        and minute for (sub-)second data.
-        `superimpose` can also be a valid [Pandas offset string],
-        such as `'5T'` or `'5min'`, in which case this frequency will be
-        used to superimpose.
-        Note, this only works for data with a datetime index.
-
-        If `resample` is `True`, the OHLC data is resampled in a way that
-        makes the upper number of candles for Bokeh to plot limited to 10_000.
-        This may, in situations of overabundant data,
-        improve plot's interactive performance and avoid browser's
-        `Javascript Error: Maximum call stack size exceeded` or similar.
-        Equity & dropdown curves and individual trades data is,
-        likewise, [reasonably _aggregated_][TRADES_AGG].
-        `resample` can also be a [Pandas offset string],
-        such as `'5T'` or `'5min'`, in which case this frequency will be
-        used to resample, overriding above numeric limitation.
-        Note, all this only works for data with a datetime index.
-
-        If `reverse_indicators` is `True`, the indicators below the OHLC chart
-        are plotted in reverse order of declaration.
-
-        [Pandas offset string]: \
-            https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects
-
-        [TRADES_AGG]: lib.html#backtesting.lib.TRADES_AGG
-
-        If `show_legend` is `True`, the resulting plot graphs will contain
-        labeled legends.
-
-        If `open_browser` is `True`, the resulting `filename` will be
-        opened in the default web browser.
-        """
-        if results is None:
-            if self._results is None:
-                raise RuntimeError('First issue `backtest.run()` to obtain results.')
-            results = self._results
-
-        return plot(
-            results=results,
-            df=self._data,
-            indicators=results._strategy._indicators,
-            filename=filename,
-            plot_width=plot_width,
-            plot_equity=plot_equity,
-            plot_return=plot_return,
-            plot_pl=plot_pl,
-            plot_volume=plot_volume,
-            plot_drawdown=plot_drawdown,
-            plot_trades=plot_trades,
-            smooth_equity=smooth_equity,
-            relative_equity=relative_equity,
-            superimpose=superimpose,
-            resample=resample,
-            reverse_indicators=reverse_indicators,
-            show_legend=show_legend,
-            open_browser=open_browser)
-
-
-# NOTE: Don't put anything public below this __all__ list
-
-__all__ = [getattr(v, '__name__', k)
-           for k, v in globals().items()                        # export
-           if ((callable(v) and getattr(v, '__module__', None) == __name__ or  # callables from this module; getattr for Python 3.9; # noqa: E501
-                k.isupper()) and                                # or CONSTANTS
-               not getattr(v, '__name__', k).startswith('_'))]  # neither marked internal
-
-# NOTE: Don't put anything public below here. See above.