Add to_series to official Timeseries contract, change as_series to to_series

Represent results as actual Timeseries object rather than lists

Make Backtest preserve the backend string so that it can get different
structures for that backend rather than only the PastView

Author: jathoms

README.md

@@ -109,7 +109,7 @@ def aapl_momentum_with_liquidity(
 
     # liquidity filter: average recent volume
     if aapl_volume is not None and len(aapl_volume) >= vol_window:
-        avg_vol = aapl_volume[-vol_window:].as_series().mean()
+        avg_vol = aapl_volume[-vol_window:].mean()
         vol_ok = avg_vol is not None and avg_vol > 0
     else:
         avg_vol = None

src/backtest_lib/backtest/__init__.py

@@ -121,7 +121,7 @@ class Backtest:
     _current_portfolio: Portfolio
     settings: BacktestSettings
     _schedule: DecisionSchedule
-    _backend: type[PastView]
+    _backend: str
     _engine: Engine
 
     def __init__(
@@ -155,7 +155,7 @@ def __init__(
             self._schedule = make_decision_schedule(market_view.periods)
         else:
             self._schedule = decision_schedule
-        self._backend = get_pastview_type_from_backend(backend)
+        self._backend = backend
 
         self._engine = engine or make_engine(
             PerfectWorldPlanGenerator(),
@@ -234,7 +234,9 @@ def run(self, ctx: StrategyContext | None = None) -> BacktestResults:
                     )
                     break
 
-        allocation_history: PastView = self._backend.from_security_mappings(
+        allocation_history: PastView = get_pastview_type_from_backend(
+            self._backend
+        ).from_security_mappings(
             output_holdings,
             self.market_view.periods[:i],
         )

src/backtest_lib/backtest/results.py

@@ -6,6 +6,12 @@
 from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
+from backtest_lib.market import (
+    get_pastview_type_from_backend,
+    get_timeseries_type_from_backend,
+)
+from backtest_lib.market.timeseries import Timeseries
+
 if TYPE_CHECKING:
     from backtest_lib.market import MarketView, PastView
     from backtest_lib.market.timeseries import Comparable
@@ -28,12 +34,12 @@ class BacktestResults[IndexT: Comparable]:
     asset_returns: PastView[float, IndexT] = field(repr=False)
     initial_capital: float
 
-    portfolio_returns: list[float]
-    nav: list[float]
-    drawdowns: list[float]
-    gross_exposure: list[float]
-    net_exposure: list[float]
-    turnover: list[float]
+    portfolio_returns: Timeseries[float, IndexT]
+    nav: Timeseries[float, IndexT]
+    drawdowns: Timeseries[float, IndexT]
+    gross_exposure: Timeseries[float, IndexT]
+    net_exposure: Timeseries[float, IndexT]
+    turnover: Timeseries[float, IndexT]
 
     total_return: float
     annualized_return: float
@@ -43,7 +49,9 @@ class BacktestResults[IndexT: Comparable]:
     avg_turnover: float
 
     market: MarketView[IndexT]
-    _backend: type[PastView]
+    _backend: str
+    _backend_pastview_type: type[PastView]
+    _backend_timeseries_type: type[Timeseries]
 
     @staticmethod
     def from_weights_and_returns(
@@ -54,7 +62,7 @@ def from_weights_and_returns(
         initial_capital: float = 1.0,
         periods_per_year: float = 252.0,
         risk_free_annual: float | None = None,
-        backend: type[PastView],
+        backend: str = "polars",
     ) -> BacktestResults[Any]:
         """
         Build results from pre-computed per-security simple returns.
@@ -158,18 +166,20 @@ def _std(xs: list[float]) -> float:
             )
             sharpe = (annualized_return - risk_free_annual) / annualized_volatility
 
+        timeseries_type = get_timeseries_type_from_backend(backend)
+
         return BacktestResults(
             periods=periods,
             securities=securities,
             weights=weights,
             asset_returns=returns,
             initial_capital=initial_capital,
-            portfolio_returns=portfolio_returns,
-            nav=nav,
-            drawdowns=drawdowns,
-            gross_exposure=gross_exposure,
-            net_exposure=net_exposure,
-            turnover=turnover,
+            portfolio_returns=timeseries_type.from_vectors(portfolio_returns, periods),
+            nav=timeseries_type.from_vectors(nav, periods),
+            drawdowns=timeseries_type.from_vectors(drawdowns, periods),
+            gross_exposure=timeseries_type.from_vectors(gross_exposure, periods),
+            net_exposure=timeseries_type.from_vectors(net_exposure, periods),
+            turnover=timeseries_type.from_vectors(turnover, periods),
             total_return=total_return,
             annualized_return=annualized_return,
             annualized_volatility=annualized_volatility,
@@ -178,6 +188,8 @@ def _std(xs: list[float]) -> float:
             avg_turnover=avg_turnover,
             market=market,
             _backend=backend,
+            _backend_pastview_type=get_pastview_type_from_backend(backend),
+            _backend_timeseries_type=timeseries_type,
         )
 
     @staticmethod
@@ -188,7 +200,7 @@ def from_weights_market_initial_capital(
         *,
         periods_per_year: float = 252.0,
         risk_free_annual: float | None = 0.02,
-        backend: type[PastView],
+        backend: str,
     ) -> BacktestResults[Any]:
         """
         Convenience constructor that derives per-security returns from
@@ -244,7 +256,9 @@ def from_weights_market_initial_capital(
             .collect()
         )
 
-        asset_returns: PastView = backend.from_dataframe(asset_returns_df)
+        backend_pastview_type = get_pastview_type_from_backend(backend)
+
+        asset_returns: PastView = backend_pastview_type.from_dataframe(asset_returns_df)
 
         results = BacktestResults.from_weights_and_returns(
             weights=weights,
@@ -273,17 +287,16 @@ def quantities_held(self) -> PastView[float, IndexT]:
             )
             if dtype.is_numeric()
         ]
-        nav_series = pl.Series(self.nav)
 
         qtys = joined.select(
             "date",
             *[
-                (pl.col(c) * nav_series / pl.col(f"{c}_p")).alias(c)
+                (pl.col(c) * self.nav.to_series() / pl.col(f"{c}_p")).alias(c)
                 for c in numeric_cols
             ],
         )
 
-        return self._backend.from_dataframe(qtys.collect())
+        return self._backend_pastview_type.from_dataframe(qtys.collect())
 
     @cached_property
     def values_held(self) -> PastView[float, IndexT]:
@@ -297,11 +310,10 @@ def values_held(self) -> PastView[float, IndexT]:
             )
             if dtype.is_numeric()
         ]
-        nav_series = pl.Series(self.nav)
 
         values = weights.select(
             "date",
-            *[(pl.col(c) * nav_series).alias(c) for c in numeric_cols],
+            *[(pl.col(c) * self.nav.to_series()).alias(c) for c in numeric_cols],
         )
 
-        return self._backend.from_dataframe(values.collect())
+        return self._backend_pastview_type.from_dataframe(values.collect())

src/backtest_lib/examples/ewma.ipynb

@@ -150,7 +150,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "aapl_prices = past_cost_prices.by_security[\"AAPL\"].as_series()\n",
+    "aapl_prices = past_cost_prices.by_security[\"AAPL\"].to_series()\n",
     "\n",
     "print(aapl_prices.pct_change() + 1)\n",
     "print((aapl_prices.pct_change() + 1).cum_prod())"

src/backtest_lib/examples/full_sp500_test.ipynb

@@ -199,7 +199,7 @@
     "final_allocations = pl.DataFrame(\n",
     "    data={\n",
     "        \"security\": final_allocations_series.names,\n",
-    "        \"value\": final_allocations_series.as_series(),\n",
+    "        \"value\": final_allocations_series.to_series(),\n",
     "    },\n",
     ").filter(pl.col(\"value\") > 0)\n",
     "\n",
@@ -225,7 +225,7 @@
    "outputs": [],
    "source": [
     "nvda_pnl = list(\n",
-    "    (results.asset_returns.by_security[\"NVDA\"].as_series() + 1)\n",
+    "    (results.asset_returns.by_security[\"NVDA\"].to_series() + 1)\n",
     "    .cum_prod()\n",
     "    .rolling_mean(10, min_samples=10),\n",
     ")\n",

src/backtest_lib/examples/sp500.ipynb

@@ -298,7 +298,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "neg_series = bt._current_portfolio.holdings.as_series()\n",
+    "neg_series = bt._current_portfolio.holdings.to_series()\n",
     "neg_mass = neg_series.clip(upper_bound=0).sum()\n",
     "pos_mass = neg_series.clip(lower_bound=0).sum()\n",
     "pos_only_series = neg_series.clip(lower_bound=0)\n",
@@ -381,8 +381,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "results.holdings.by_security[\"AAPL\"].as_series().min()\n",
-    "results.weights.by_security[\"AAPL\"].as_series().min()"
+    "results.holdings.by_security[\"AAPL\"].to_series().min()\n",
+    "results.weights.by_security[\"AAPL\"].to_series().min()"
    ]
   },
   {

src/backtest_lib/market/polars_impl/_axis.py

@@ -39,10 +39,9 @@ def from_series(date_s: pl.Series, fmt: str = "%Y-%m-%d") -> PeriodAxis:
             date_s = date_s.cast(pl.Datetime("us"))
         labels = tuple(date_s.dt.strftime(fmt).to_list())
         dt64 = date_s.to_numpy().astype("datetime64[us]", copy=False)
-        # assert np.all(dt64[1:] >= dt64[:-1])
         return PeriodAxis(dt64, labels, {lbl: i for i, lbl in enumerate(labels)})
 
-    def take(self, idxs: Sequence[int] | NDArray[np.int64]) -> PeriodAxis:
+    def take(self, idxs: Sequence[int] | NDArray[np.integer]) -> PeriodAxis:
         """
         Creates a new PeriodAxis from a sequence of
         integer indices contained in the period axis.

src/backtest_lib/market/polars_impl/_plotting.py

@@ -60,7 +60,7 @@ def line(
 class PolarsUniverseMappingPlotAccessor(UniverseMappingPlotAccessor):
     def __init__(self, obj: PolarsUniverseMapping):
         self._obj = obj
-        self._series = obj.as_series()
+        self._series = obj.to_series()
 
     def __call__(
         self,
@@ -165,7 +165,7 @@ def stacked_bar(
 class PolarsTimeseriesPlotAccessor(TimeseriesPlotAccessor):
     def __init__(self, obj: PolarsTimeseries):
         self._obj = obj
-        self._series = obj.as_series()
+        self._series = obj.to_series()
 
     def __call__(self, **kwargs) -> alt.Chart:
         return self.line(**kwargs)