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

BackcastPro/lib.py

@@ -0,0 +1,646 @@
+"""
+Collection of common building blocks, helper auxiliary functions and
+composable strategy classes for reuse.
+
+Intended for simple missing-link procedures, not reinventing
+of better-suited, state-of-the-art, fast libraries,
+such as TA-Lib, Tulipy, PyAlgoTrade, NumPy, SciPy ...
+
+Please raise ideas for additions to this collection on the [issue tracker].
+
+[issue tracker]: https://github.com/kernc/backtesting.py
+"""
+
+from __future__ import annotations
+
+import warnings
+from collections import OrderedDict
+from inspect import currentframe
+from itertools import chain, compress, count
+from numbers import Number
+from typing import Callable, Generator, Optional, Sequence, Union
+
+import numpy as np
+import pandas as pd
+
+from ._plotting import plot_heatmaps as _plot_heatmaps
+from ._stats import compute_stats as _compute_stats
+from ._util import SharedMemoryManager, _Array, _as_str, _batch, _tqdm, patch
+from .backtesting import Backtest, Strategy
+
+__pdoc__ = {}
+
+
+OHLCV_AGG = OrderedDict((
+    ('Open', 'first'),
+    ('High', 'max'),
+    ('Low', 'min'),
+    ('Close', 'last'),
+    ('Volume', 'sum'),
+))
+"""Dictionary of rules for aggregating resampled OHLCV data frames,
+e.g.
+
+    df.resample('4H', label='right').agg(OHLCV_AGG).dropna()
+"""
+
+TRADES_AGG = OrderedDict((
+    ('Size', 'sum'),
+    ('EntryBar', 'first'),
+    ('ExitBar', 'last'),
+    ('EntryPrice', 'mean'),
+    ('ExitPrice', 'mean'),
+    ('PnL', 'sum'),
+    ('ReturnPct', 'mean'),
+    ('EntryTime', 'first'),
+    ('ExitTime', 'last'),
+    ('Duration', 'sum'),
+))
+"""Dictionary of rules for aggregating resampled trades data,
+e.g.
+
+    stats['_trades'].resample('1D', on='ExitTime',
+                              label='right').agg(TRADES_AGG)
+"""
+
+_EQUITY_AGG = {
+    'Equity': 'last',
+    'DrawdownPct': 'max',
+    'DrawdownDuration': 'max',
+}
+
+
+def barssince(condition: Sequence[bool], default=np.inf) -> int:
+    """
+    Return the number of bars since `condition` sequence was last `True`,
+    or if never, return `default`.
+
+        >>> barssince(self.data.Close > self.data.Open)
+        3
+    """
+    return next(compress(range(len(condition)), reversed(condition)), default)
+
+
+def cross(series1: Sequence, series2: Sequence) -> bool:
+    """
+    Return `True` if `series1` and `series2` just crossed
+    (above or below) each other.
+
+        >>> cross(self.data.Close, self.sma)
+        True
+
+    """
+    return crossover(series1, series2) or crossover(series2, series1)
+
+
+def crossover(series1: Sequence, series2: Sequence) -> bool:
+    """
+    Return `True` if `series1` just crossed over (above)
+    `series2`.
+
+        >>> crossover(self.data.Close, self.sma)
+        True
+    """
+    series1 = (
+        series1.values if isinstance(series1, pd.Series) else
+        (series1, series1) if isinstance(series1, Number) else
+        series1)
+    series2 = (
+        series2.values if isinstance(series2, pd.Series) else
+        (series2, series2) if isinstance(series2, Number) else
+        series2)
+    try:
+        return series1[-2] < series2[-2] and series1[-1] > series2[-1]  # type: ignore
+    except IndexError:
+        return False
+
+
+def plot_heatmaps(heatmap: pd.Series,
+                  agg: Union[str, Callable] = 'max',
+                  *,
+                  ncols: int = 3,
+                  plot_width: int = 1200,
+                  filename: str = '',
+                  open_browser: bool = True):
+    """
+    Plots a grid of heatmaps, one for every pair of parameters in `heatmap`.
+    See example in [the tutorial].
+
+    [the tutorial]: https://kernc.github.io/backtesting.py/doc/examples/Parameter%20Heatmap%20&%20Optimization.html#plot-heatmap  # noqa: E501
+
+    `heatmap` is a Series as returned by
+    `backtesting.backtesting.Backtest.optimize` when its parameter
+    `return_heatmap=True`.
+
+    When projecting the n-dimensional (n > 2) heatmap onto 2D, the values are
+    aggregated by 'max' function by default. This can be tweaked
+    with `agg` parameter, which accepts any argument pandas knows
+    how to aggregate by.
+
+    .. todo::
+        Lay heatmaps out lower-triangular instead of in a simple grid.
+        Like [`sambo.plot.plot_objective()`][plot_objective] does.
+
+    [plot_objective]: \
+        https://sambo-optimization.github.io/doc/sambo/plot.html#sambo.plot.plot_objective
+    """
+    return _plot_heatmaps(heatmap, agg, ncols, filename, plot_width, open_browser)
+
+
+def quantile(series: Sequence, quantile: Union[None, float] = None):
+    """
+    If `quantile` is `None`, return the quantile _rank_ of the last
+    value of `series` wrt former series values.
+
+    If `quantile` is a value between 0 and 1, return the _value_ of
+    `series` at this quantile. If used to working with percentiles, just
+    divide your percentile amount with 100 to obtain quantiles.
+
+        >>> quantile(self.data.Close[-20:], .1)
+        162.130
+        >>> quantile(self.data.Close)
+        0.13
+    """
+    if quantile is None:
+        try:
+            last, series = series[-1], series[:-1]
+            return np.mean(series < last)
+        except IndexError:
+            return np.nan
+    assert 0 <= quantile <= 1, "quantile must be within [0, 1]"
+    return np.nanpercentile(series, quantile * 100)
+
+
+def compute_stats(
+        *,
+        stats: pd.Series,
+        data: pd.DataFrame,
+        trades: pd.DataFrame = None,
+        risk_free_rate: float = 0.) -> pd.Series:
+    """
+    (Re-)compute strategy performance metrics.
+
+    `stats` is the statistics series as returned by `backtesting.backtesting.Backtest.run()`.
+    `data` is OHLC data as passed to the `backtesting.backtesting.Backtest`
+    the `stats` were obtained in.
+    `trades` can be a dataframe subset of `stats._trades` (e.g. only long trades).
+    You can also tune `risk_free_rate`, used in calculation of Sharpe and Sortino ratios.
+
+        >>> stats = Backtest(GOOG, MyStrategy).run()
+        >>> only_long_trades = stats._trades[stats._trades.Size > 0]
+        >>> long_stats = compute_stats(stats=stats, trades=only_long_trades,
+        ...                            data=GOOG, risk_free_rate=.02)
+    """
+    equity = stats._equity_curve.Equity
+    if trades is None:
+        trades = stats._trades
+    else:
+        # XXX: Is this buggy?
+        equity = equity.copy()
+        equity[:] = stats._equity_curve.Equity.iloc[0]
+        for t in trades.itertuples(index=False):
+            equity.iloc[t.EntryBar:] += t.PnL
+    return _compute_stats(trades=trades, equity=equity.values, ohlc_data=data,
+                          risk_free_rate=risk_free_rate, strategy_instance=stats._strategy)
+
+
+def resample_apply(rule: str,
+                   func: Optional[Callable[..., Sequence]],
+                   series: Union[pd.Series, pd.DataFrame, _Array],
+                   *args,
+                   agg: Optional[Union[str, dict]] = None,
+                   **kwargs):
+    """
+    Apply `func` (such as an indicator) to `series`, resampled to
+    a time frame specified by `rule`. When called from inside
+    `backtesting.backtesting.Strategy.init`,
+    the result (returned) series will be automatically wrapped in
+    `backtesting.backtesting.Strategy.I`
+    wrapper method.
+
+    `rule` is a valid [Pandas offset string] indicating
+    a time frame to resample `series` to.
+
+    [Pandas offset string]: \
+http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases
+
+    `func` is the indicator function to apply on the resampled series.
+
+    `series` is a data series (or array), such as any of the
+    `backtesting.backtesting.Strategy.data` series. Due to pandas
+    resampling limitations, this only works when input series
+    has a datetime index.
+
+    `agg` is the aggregation function to use on resampled groups of data.
+    Valid values are anything accepted by `pandas/resample/.agg()`.
+    Default value for dataframe input is `OHLCV_AGG` dictionary.
+    Default value for series input is the appropriate entry from `OHLCV_AGG`
+    if series has a matching name, or otherwise the value `"last"`,
+    which is suitable for closing prices,
+    but you might prefer another (e.g. `"max"` for peaks, or similar).
+
+    Finally, any `*args` and `**kwargs` that are not already eaten by
+    implicit `backtesting.backtesting.Strategy.I` call
+    are passed to `func`.
+
+    For example, if we have a typical moving average function
+    `SMA(values, lookback_period)`, _hourly_ data source, and need to
+    apply the moving average MA(10) on a _daily_ time frame,
+    but don't want to plot the resulting indicator, we can do:
+
+        class System(Strategy):
+            def init(self):
+                self.sma = resample_apply(
+                    'D', SMA, self.data.Close, 10, plot=False)
+
+    The above short snippet is roughly equivalent to:
+
+        class System(Strategy):
+            def init(self):
+                # Strategy exposes `self.data` as raw NumPy arrays.
+                # Let's convert closing prices back to pandas Series.
+                close = self.data.Close.s
+
+                # Resample to daily resolution. Aggregate groups
+                # using their last value (i.e. closing price at the end
+                # of the day). Notice `label='right'`. If it were set to
+                # 'left' (default), the strategy would exhibit
+                # look-ahead bias.
+                daily = close.resample('D', label='right').agg('last')
+
+                # We apply SMA(10) to daily close prices,
+                # then reindex it back to original hourly index,
+                # forward-filling the missing values in each day.
+                # We make a separate function that returns the final
+                # indicator array.
+                def SMA(series, n):
+                    from BackcastPro.test import SMA
+                    return SMA(series, n).reindex(close.index).ffill()
+
+                # The result equivalent to the short example above:
+                self.sma = self.I(SMA, daily, 10, plot=False)
+
+    """
+    if func is None:
+        def func(x, *_, **__):
+            return x
+    assert callable(func), 'resample_apply(func=) must be callable'
+
+    if not isinstance(series, (pd.Series, pd.DataFrame)):
+        assert isinstance(series, _Array), \
+            'resample_apply(series=) must be `pd.Series`, `pd.DataFrame`, ' \
+            'or a `Strategy.data.*` array'
+        series = series.s
+
+    if agg is None:
+        agg = OHLCV_AGG.get(getattr(series, 'name', ''), 'last')
+        if isinstance(series, pd.DataFrame):
+            agg = {column: OHLCV_AGG.get(column, 'last')
+                   for column in series.columns}
+
+    resampled = series.resample(rule, label='right').agg(agg).dropna()
+    resampled.name = _as_str(series) + '[' + rule + ']'
+
+    # Check first few stack frames if we are being called from
+    # inside Strategy.init, and if so, extract Strategy.I wrapper.
+    frame, level = currentframe(), 0
+    while frame and level <= 3:
+        frame = frame.f_back
+        level += 1
+        if isinstance(frame.f_locals.get('self'), Strategy):  # type: ignore
+            strategy_I = frame.f_locals['self'].I             # type: ignore
+            break
+    else:
+        def strategy_I(func, *args, **kwargs):  # noqa: F811
+            return func(*args, **kwargs)
+
+    def wrap_func(resampled, *args, **kwargs):
+        result = func(resampled, *args, **kwargs)
+        if not isinstance(result, pd.DataFrame) and not isinstance(result, pd.Series):
+            result = np.asarray(result)
+            if result.ndim == 1:
+                result = pd.Series(result, name=resampled.name)
+            elif result.ndim == 2:
+                result = pd.DataFrame(result.T)
+        # Resample back to data index
+        if not isinstance(result.index, pd.DatetimeIndex):
+            result.index = resampled.index
+        result = result.reindex(index=series.index.union(resampled.index),
+                                method='ffill').reindex(series.index)
+        return result
+
+    wrap_func.__name__ = func.__name__
+
+    array = strategy_I(wrap_func, resampled, *args, **kwargs)
+    return array
+
+
+def random_ohlc_data(example_data: pd.DataFrame, *,
+                     frac=1., random_state: Optional[int] = None) -> Generator[pd.DataFrame, None, None]:
+    """
+    OHLC data generator. The generated OHLC data has basic
+    [descriptive statistics](https://en.wikipedia.org/wiki/Descriptive_statistics)
+    similar to the provided `example_data`.
+
+    `frac` is a fraction of data to sample (with replacement). Values greater
+    than 1 result in oversampling.
+
+    Such random data can be effectively used for stress testing trading
+    strategy robustness, Monte Carlo simulations, significance testing, etc.
+
+    >>> from BackcastPro.test import EURUSD
+    >>> ohlc_generator = random_ohlc_data(EURUSD)
+    >>> next(ohlc_generator)  # returns new random data
+    ...
+    >>> next(ohlc_generator)  # returns new random data
+    ...
+    """
+    def shuffle(x):
+        return x.sample(frac=frac, replace=frac > 1, random_state=random_state)
+
+    if len(example_data.columns.intersection({'Open', 'High', 'Low', 'Close'})) != 4:
+        raise ValueError("`data` must be a pandas.DataFrame with columns "
+                         "'Open', 'High', 'Low', 'Close'")
+    while True:
+        df = shuffle(example_data)
+        df.index = example_data.index
+        padding = df.Close - df.Open.shift(-1)
+        gaps = shuffle(example_data.Open.shift(-1) - example_data.Close)
+        deltas = (padding + gaps).shift(1).fillna(0).cumsum()
+        for key in ('Open', 'High', 'Low', 'Close'):
+            df[key] += deltas
+        yield df
+
+
+class SignalStrategy(Strategy):
+    """
+    A simple helper strategy that operates on position entry/exit signals.
+    This makes the backtest of the strategy simulate a [vectorized backtest].
+    See [tutorials] for usage examples.
+
+    [vectorized backtest]: https://www.google.com/search?q=vectorized+backtest
+    [tutorials]: index.html#tutorials
+
+    To use this helper strategy, subclass it, override its
+    `backtesting.backtesting.Strategy.init` method,
+    and set the signal vector by calling
+    `backtesting.lib.SignalStrategy.set_signal` method from within it.
+
+        class ExampleStrategy(SignalStrategy):
+            def init(self):
+                super().init()
+                self.set_signal(sma1 > sma2, sma1 < sma2)
+
+    Remember to call `super().init()` and `super().next()` in your
+    overridden methods.
+    """
+    __entry_signal = (0,)
+    __exit_signal = (False,)
+
+    def set_signal(self, entry_size: Sequence[float],
+                   exit_portion: Optional[Sequence[float]] = None,
+                   *,
+                   plot: bool = True):
+        """
+        Set entry/exit signal vectors (arrays).
+
+        A long entry signal is considered present wherever `entry_size`
+        is greater than zero, and a short signal wherever `entry_size`
+        is less than zero, following `backtesting.backtesting.Order.size` semantics.
+
+        If `exit_portion` is provided, a nonzero value closes portion the position
+        (see `backtesting.backtesting.Trade.close()`) in the respective direction
+        (positive values close long trades, negative short).
+
+        If `plot` is `True`, the signal entry/exit indicators are plotted when
+        `backtesting.backtesting.Backtest.plot` is called.
+        """
+        self.__entry_signal = self.I(  # type: ignore
+            lambda: pd.Series(entry_size, dtype=float).replace(0, np.nan),
+            name='entry size', plot=plot, overlay=False, scatter=True, color='black')
+
+        if exit_portion is not None:
+            self.__exit_signal = self.I(  # type: ignore
+                lambda: pd.Series(exit_portion, dtype=float).replace(0, np.nan),
+                name='exit portion', plot=plot, overlay=False, scatter=True, color='black')
+
+    def next(self):
+        super().next()
+
+        exit_portion = self.__exit_signal[-1]
+        if exit_portion > 0:
+            for trade in self.trades:
+                if trade.is_long:
+                    trade.close(exit_portion)
+        elif exit_portion < 0:
+            for trade in self.trades:
+                if trade.is_short:
+                    trade.close(-exit_portion)
+
+        entry_size = self.__entry_signal[-1]
+        if entry_size > 0:
+            self.buy(size=entry_size)
+        elif entry_size < 0:
+            self.sell(size=-entry_size)
+
+
+class TrailingStrategy(Strategy):
+    """
+    A strategy with automatic trailing stop-loss, trailing the current
+    price at distance of some multiple of average true range (ATR). Call
+    `TrailingStrategy.set_trailing_sl()` to set said multiple
+    (`6` by default). See [tutorials] for usage examples.
+
+    [tutorials]: index.html#tutorials
+
+    Remember to call `super().init()` and `super().next()` in your
+    overridden methods.
+    """
+    __n_atr = 6.
+    __atr = None
+
+    def init(self):
+        super().init()
+        self.set_atr_periods()
+
+    def set_atr_periods(self, periods: int = 100):
+        """
+        Set the lookback period for computing ATR. The default value
+        of 100 ensures a _stable_ ATR.
+        """
+        hi, lo, c_prev = self.data.High, self.data.Low, pd.Series(self.data.Close).shift(1)
+        tr = np.max([hi - lo, (c_prev - hi).abs(), (c_prev - lo).abs()], axis=0)
+        atr = pd.Series(tr).rolling(periods).mean().bfill().values
+        self.__atr = atr
+
+    def set_trailing_sl(self, n_atr: float = 6):
+        """
+        Set the future trailing stop-loss as some multiple (`n_atr`)
+        average true bar ranges away from the current price.
+        """
+        self.__n_atr = n_atr
+
+    def set_trailing_pct(self, pct: float = .05):
+        """
+        Set the future trailing stop-loss as some percent (`0 < pct < 1`)
+        below the current price (default 5% below).
+
+        .. note:: Stop-loss set by `pct` is inexact
+            Stop-loss set by `set_trailing_pct` is converted to units of ATR
+            with `mean(Close * pct / atr)` and set with `set_trailing_sl`.
+        """
+        assert 0 < pct < 1, 'Need pct= as rate, i.e. 5% == 0.05'
+        pct_in_atr = np.mean(self.data.Close * pct / self.__atr)  # type: ignore
+        self.set_trailing_sl(pct_in_atr)
+
+    def next(self):
+        super().next()
+        # Can't use index=-1 because self.__atr is not an Indicator type
+        index = len(self.data) - 1
+        for trade in self.trades:
+            if trade.is_long:
+                trade.sl = max(trade.sl or -np.inf,
+                               self.data.Close[index] - self.__atr[index] * self.__n_atr)
+            else:
+                trade.sl = min(trade.sl or np.inf,
+                               self.data.Close[index] + self.__atr[index] * self.__n_atr)
+
+
+class FractionalBacktest(Backtest):
+    """
+    A `backtesting.backtesting.Backtest` that supports fractional share trading
+    by simple composition. It applies roughly the transformation:
+
+        data = (data * fractional_unit).assign(Volume=data.Volume / fractional_unit)
+
+    as left unchallenged in [this FAQ entry on GitHub](https://github.com/kernc/backtesting.py/issues/134),
+    then passes `data`, `args*`, and `**kwargs` to its super.
+
+    Parameter `fractional_unit` represents the smallest fraction of currency that can be traded
+    and defaults to one [satoshi]. For μBTC trading, pass `fractional_unit=1/1e6`.
+    Thus-transformed backtest does a whole-sized trading of `fractional_unit` units.
+
+    [satoshi]: https://en.wikipedia.org/wiki/Bitcoin#Units_and_divisibility
+    """
+    def __init__(self,
+                 data,
+                 *args,
+                 fractional_unit=1 / 100e6,
+                 **kwargs):
+        if 'satoshi' in kwargs:
+            warnings.warn(
+                'Parameter `FractionalBacktest(..., satoshi=)` is deprecated. '
+                'Use `FractionalBacktest(..., fractional_unit=)`.',
+                category=DeprecationWarning, stacklevel=2)
+            fractional_unit = 1 / kwargs.pop('satoshi')
+        self._fractional_unit = fractional_unit
+        self.__data: pd.DataFrame = data.copy(deep=False)  # Shallow copy
+        for col in ('Open', 'High', 'Low', 'Close',):
+            self.__data[col] = self.__data[col] * self._fractional_unit
+        for col in ('Volume',):
+            self.__data[col] = self.__data[col] / self._fractional_unit
+        with warnings.catch_warnings(record=True):
+            warnings.filterwarnings(action='ignore', message='frac')
+            super().__init__(data, *args, **kwargs)
+
+    def run(self, **kwargs) -> pd.Series:
+        with patch(self, '_data', self.__data):
+            result = super().run(**kwargs)
+
+        trades: pd.DataFrame = result['_trades']
+        trades['Size'] *= self._fractional_unit
+        trades[['EntryPrice', 'ExitPrice', 'TP', 'SL']] /= self._fractional_unit
+
+        indicators = result['_strategy']._indicators
+        for indicator in indicators:
+            if indicator._opts['overlay']:
+                indicator /= self._fractional_unit
+
+        return result
+
+
+# Prevent pdoc3 documenting __init__ signature of Strategy subclasses
+for cls in list(globals().values()):
+    if isinstance(cls, type) and issubclass(cls, Strategy):
+        __pdoc__[f'{cls.__name__}.__init__'] = False
+
+
+class MultiBacktest:
+    """
+    Multi-dataset `backtesting.backtesting.Backtest` wrapper.
+
+    Run supplied `backtesting.backtesting.Strategy` on several instruments,
+    in parallel.  Used for comparing strategy runs across many instruments
+    or classes of instruments. Example:
+
+        from BackcastPro.test import EURUSD, BTCUSD, SmaCross
+        btm = MultiBacktest([EURUSD, BTCUSD], SmaCross)
+        stats_per_ticker: pd.DataFrame = btm.run(fast=10, slow=20)
+        heatmap_per_ticker: pd.DataFrame = btm.optimize(...)
+    """
+    def __init__(self, df_list, strategy_cls, **kwargs):
+        self._dfs = df_list
+        self._strategy = strategy_cls
+        self._bt_kwargs = kwargs
+
+    def run(self, **kwargs):
+        """
+        Wraps `backtesting.backtesting.Backtest.run`. Returns `pd.DataFrame` with
+        currency indexes in columns.
+        """
+        from . import Pool
+        with Pool() as pool, \
+                SharedMemoryManager() as smm:
+            shm = [smm.df2shm(df) for df in self._dfs]
+            results = _tqdm(
+                pool.imap(self._mp_task_run,
+                          ((df_batch, self._strategy, self._bt_kwargs, kwargs)
+                           for df_batch in _batch(shm))),
+                total=len(shm),
+                desc=self.run.__qualname__,
+                mininterval=2
+            )
+            df = pd.DataFrame(list(chain(*results))).transpose()
+        return df
+
+    @staticmethod
+    def _mp_task_run(args):
+        data_shm, strategy, bt_kwargs, run_kwargs = args
+        dfs, shms = zip(*(SharedMemoryManager.shm2df(i) for i in data_shm))
+        try:
+            return [stats.filter(regex='^[^_]') if stats['# Trades'] else None
+                    for stats in (Backtest(df, strategy, **bt_kwargs).run(**run_kwargs)
+                                  for df in dfs)]
+        finally:
+            for shmem in chain(*shms):
+                shmem.close()
+
+    def optimize(self, **kwargs) -> pd.DataFrame:
+        """
+        Wraps `backtesting.backtesting.Backtest.optimize`, but returns `pd.DataFrame` with
+        currency indexes in columns.
+
+            heamap: pd.DataFrame = btm.optimize(...)
+            from BackcastPro.plot import plot_heatmaps
+            plot_heatmaps(heatmap.mean(axis=1))
+        """
+        heatmaps = []
+        # Simple loop since bt.optimize already does its own multiprocessing
+        for df in _tqdm(self._dfs, desc=self.__class__.__name__, mininterval=2):
+            bt = Backtest(df, self._strategy, **self._bt_kwargs)
+            _best_stats, heatmap = bt.optimize(  # type: ignore
+                return_heatmap=True, return_optimization=False, **kwargs)
+            heatmaps.append(heatmap)
+        heatmap = pd.DataFrame(dict(zip(count(), heatmaps)))
+        return heatmap
+
+
+# NOTE: Don't put anything 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
+                k.isupper()) and                                # or CONSTANTS
+               not getattr(v, '__name__', k).startswith('_'))]  # neither marked internal
+
+# NOTE: Don't put anything below here. See above.

BackcastPro/test/__init__.py

@@ -0,0 +1,29 @@
+"""Data and utilities for testing."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+
+def _read_file(filename):
+    from os.path import dirname, join
+
+    return pd.read_csv(join(dirname(__file__), filename),
+                       index_col=0, parse_dates=True)
+
+
+BTCUSD = _read_file('BTCUSD.csv')
+"""DataFrame of monthly BTC/USD histrical index data from 2012 through 2024 (12 years)."""
+
+GOOG = _read_file('GOOG.csv')
+"""DataFrame of daily NASDAQ:GOOG (Google/Alphabet) stock price data from 2004 to 2013."""
+
+EURUSD = _read_file('EURUSD.csv')
+"""DataFrame of hourly EUR/USD forex data from April 2017 to February 2018."""
+
+
+def SMA(arr: pd.Series, n: int) -> pd.Series:
+    """
+    Returns `n`-period simple moving average of array `arr`.
+    """
+    return pd.Series(arr).rolling(n).mean()

BackcastPro/test/__main__.py

@@ -0,0 +1,7 @@
+import unittest
+import warnings
+
+
+if __name__ == '__main__':
+    warnings.filterwarnings('error')
+    unittest.main(module='backtesting.test._test', verbosity=2)