pwb-toolbox 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

pwb_toolbox/backtest/__init__.py

@@ -14,6 +14,8 @@ from .portfolio_models import (
     DollarCostAveragingPortfolioConstructionModel,
     InsightRatioPortfolioConstructionModel,
 )
+from .ib_connector import IBConnector, run_ib_strategy
+from .example.engine import run_backtest, run_ib_backtest
 
 __all__ = [
     "Direction",
@@ -37,6 +39,10 @@ __all__ = [
     "SectorExposureRiskManagementModel",
     "MaximumOrderQuantityPercentPerSecurity",
     "CompositeRiskManagementModel",
+    "IBConnector",
+    "run_ib_strategy",
+    "run_backtest",
+    "run_ib_backtest",
 ]
 from .risk_models import (
     RiskManagementModel,

pwb_toolbox/backtest/ib_connector.py

@@ -0,0 +1,69 @@
+"""Lightweight helpers for running Interactive Brokers backtests."""
+
+from __future__ import annotations
+
+from typing import Iterable, Mapping, Type
+
+import backtrader as bt
+
+
+class IBConnector:
+    """Utility for creating Backtrader IB stores and data feeds."""
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 7497,
+        client_id: int = 1,
+        store_class: Type[bt.stores.IBStore] | None = None,
+        feed_class: Type[bt.feeds.IBData] | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.client_id = client_id
+        self.store_class = store_class or bt.stores.IBStore
+        self.feed_class = feed_class or bt.feeds.IBData
+
+    def get_store(self) -> bt.stores.IBStore:
+        """Instantiate and return an ``IBStore``."""
+        return self.store_class(host=self.host, port=self.port, clientId=self.client_id)
+
+    def create_feed(self, **kwargs) -> bt.feeds.IBData:
+        """Create an ``IBData`` feed bound to the connector's store."""
+        store = kwargs.pop("store", None) or self.get_store()
+        return self.feed_class(store=store, **kwargs)
+
+
+def run_ib_strategy(
+    strategy: type[bt.Strategy],
+    data_config: Iterable[Mapping[str, object]],
+    **ib_kwargs,
+):
+    """Run ``strategy`` with Interactive Brokers data feeds.
+
+    Parameters
+    ----------
+    strategy:
+        The ``bt.Strategy`` subclass to execute.
+    data_config:
+        Iterable of dictionaries passed to ``IBData`` for each feed.
+    ib_kwargs:
+        Arguments forwarded to :class:`IBConnector`.
+    Examples
+    --------
+    >>> data_cfg = [{"dataname": "AAPL", "name": "AAPL", "what": "MIDPOINT"}]
+    >>> run_ib_strategy(MyStrategy, data_cfg, host="127.0.0.1")
+
+    """
+    connector = IBConnector(**ib_kwargs)
+    cerebro = bt.Cerebro()
+    store = connector.get_store()
+    cerebro.broker = store.getbroker()
+
+    for cfg in data_config:
+        data = connector.create_feed(store=store, **cfg)
+        name = cfg.get("name")
+        cerebro.adddata(data, name=name)
+
+    cerebro.addstrategy(strategy)
+    return cerebro.run()

pwb_toolbox/datasets/__init__.py

@@ -6,9 +6,12 @@ import re
 import datasets as ds
 import pandas as pd
 
-HF_ACCESS_TOKEN = os.environ["HF_ACCESS_TOKEN"]
-if not HF_ACCESS_TOKEN:
-    raise ValueError("Hugging Face access token not found in environment variables")
+
+def _get_hf_token() -> str:
+    token = os.getenv("HF_ACCESS_TOKEN")
+    if not token:
+        raise ValueError("HF_ACCESS_TOKEN not set")
+    return token
 
 
 DAILY_PRICE_DATASETS = [
@@ -552,7 +555,7 @@ def load_dataset(
     to_usd=True,
     rate_to_price=True,
 ):
-    dataset = ds.load_dataset(f"paperswithbacktest/{path}", token=HF_ACCESS_TOKEN)
+    dataset = ds.load_dataset(f"paperswithbacktest/{path}", token=_get_hf_token())
     df = dataset["train"].to_pandas()
 
     if path in DAILY_PRICE_DATASETS or path in DAILY_FINANCIAL_DATASETS:

pwb_toolbox/performance/__init__.py

@@ -0,0 +1,123 @@
+from .metrics import (
+    total_return,
+    cagr,
+    returns_table,
+    rolling_cumulative_return,
+    annualized_volatility,
+    max_drawdown,
+    ulcer_index,
+    ulcer_performance_index,
+    parametric_var,
+    parametric_expected_shortfall,
+    tail_ratio,
+    sharpe_ratio,
+    sortino_ratio,
+    calmar_ratio,
+    omega_ratio,
+    information_ratio,
+    capm_alpha_beta,
+    skewness,
+    kurtosis,
+    variance_ratio,
+    acf,
+    pacf,
+    fama_french_3factor,
+    fama_french_5factor,
+    cumulative_excess_return,
+)
+
+from .trade_stats import (
+    hit_rate,
+    average_win_loss,
+    expectancy,
+    profit_factor,
+    trade_duration_distribution,
+    turnover,
+    trade_implementation_shortfall,
+    cumulative_implementation_shortfall,
+    slippage_stats,
+    latency_stats,
+)
+
+__all__ = [
+    "total_return",
+    "cagr",
+    "returns_table",
+    "rolling_cumulative_return",
+    "annualized_volatility",
+    "max_drawdown",
+    "ulcer_index",
+    "ulcer_performance_index",
+    "parametric_var",
+    "parametric_expected_shortfall",
+    "tail_ratio",
+    "sharpe_ratio",
+    "sortino_ratio",
+    "calmar_ratio",
+    "omega_ratio",
+    "information_ratio",
+    "capm_alpha_beta",
+    "skewness",
+    "kurtosis",
+    "variance_ratio",
+    "acf",
+    "pacf",
+    "fama_french_3factor",
+    "fama_french_5factor",
+    "cumulative_excess_return",
+    "hit_rate",
+    "average_win_loss",
+    "expectancy",
+    "profit_factor",
+    "trade_duration_distribution",
+    "turnover",
+    "trade_implementation_shortfall",
+    "cumulative_implementation_shortfall",
+    "slippage_stats",
+    "latency_stats",
+]
+
+try:  # pragma: no cover - optional plotting deps
+    from .plots import (
+        plot_equity_curve,
+        plot_return_heatmap,
+        plot_underwater,
+        plot_rolling_volatility,
+        plot_rolling_var,
+        plot_rolling_sharpe,
+        plot_rolling_sortino,
+        plot_return_scatter,
+        plot_cumulative_excess_return,
+        plot_factor_exposures,
+        plot_trade_return_hist,
+        plot_return_by_holding_period,
+        plot_exposure_ts,
+        plot_cumulative_shortfall,
+        plot_alpha_vs_return,
+        plot_qq_returns,
+        plot_rolling_skewness,
+        plot_rolling_kurtosis,
+    )
+
+    __all__ += [
+        "plot_equity_curve",
+        "plot_return_heatmap",
+        "plot_underwater",
+        "plot_rolling_volatility",
+        "plot_rolling_var",
+        "plot_rolling_sharpe",
+        "plot_rolling_sortino",
+        "plot_return_scatter",
+        "plot_cumulative_excess_return",
+        "plot_factor_exposures",
+        "plot_trade_return_hist",
+        "plot_return_by_holding_period",
+        "plot_exposure_ts",
+        "plot_cumulative_shortfall",
+        "plot_alpha_vs_return",
+        "plot_qq_returns",
+        "plot_rolling_skewness",
+        "plot_rolling_kurtosis",
+    ]
+except Exception:  # pragma: no cover - matplotlib may be missing
+    pass

pwb_toolbox/performance/metrics.py

@@ -0,0 +1,465 @@
+from calendar import month_abbr
+from typing import Sequence, Tuple
+from math import sqrt
+from statistics import NormalDist
+
+try:
+    import pandas as pd  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - optional dependency
+    pd = None  # type: ignore
+
+
+def _to_list(data: Sequence[float]) -> list:
+    """Convert Series-like data to list."""
+    if hasattr(data, "values"):
+        return list(data.values)
+    return list(data)
+
+
+def total_return(prices: Sequence[float]) -> float:
+    """Return total return of a price series."""
+    p = _to_list(prices)
+    if not p:
+        return 0.0
+    return p[-1] / p[0] - 1
+
+
+def cagr(prices: Sequence[float], periods_per_year: int = 252) -> float:
+    """Compound annual growth rate from a price series."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return 0.0
+    years = (len(p) - 1) / periods_per_year
+    if years == 0:
+        return 0.0
+    return (p[-1] / p[0]) ** (1 / years) - 1
+
+
+def returns_table(prices: 'pd.Series') -> 'pd.DataFrame':  # type: ignore
+    """Return monthly and yearly percentage returns from a daily price series."""
+    if pd is None:
+        raise ImportError("pandas is required for returns_table")
+
+    price_list = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(price_list))))
+
+    years = sorted({dt.year for dt in index})
+    months = list(range(1, 13))
+    data = {month_abbr[m]: [] for m in months}
+    data["Year"] = []
+
+    for year in years:
+        year_start = None
+        year_end = None
+        for m in months:
+            # indices belonging to year & month
+            idx = [i for i, dt in enumerate(index) if dt.year == year and dt.month == m]
+            if idx:
+                start = idx[0]
+                end = idx[-1]
+                ret = price_list[end] / price_list[start] - 1
+                if year_start is None:
+                    year_start = price_list[start]
+                year_end = price_list[end]
+            else:
+                ret = None
+            data[month_abbr[m]].append(ret)
+        if year_start is None:
+            data["Year"].append(None)
+        else:
+            data["Year"].append(year_end / year_start - 1)
+
+    return pd.DataFrame(data, index=years)
+
+
+def rolling_cumulative_return(prices: 'pd.Series', window: int) -> 'pd.Series':  # type: ignore
+    """Rolling cumulative return over a specified window."""
+    if pd is None:
+        raise ImportError("pandas is required for rolling_cumulative_return")
+
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    out = []
+    for i in range(len(p)):
+        if i < window:
+            out.append(None)
+        else:
+            out.append(p[i] / p[i - window] - 1)
+    s = pd.Series(out)
+    s.index = index
+    return s
+
+
+def annualized_volatility(prices: Sequence[float], periods_per_year: int = 252) -> float:
+    """Annualized volatility from a price series."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return 0.0
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mean = sum(rets) / len(rets)
+    var = sum((r - mean) ** 2 for r in rets) / len(rets)
+    return sqrt(var) * sqrt(periods_per_year)
+
+
+def max_drawdown(prices: Sequence[float]) -> Tuple[float, int]:
+    """Maximum drawdown depth and duration."""
+    p = _to_list(prices)
+    if not p:
+        return 0.0, 0
+    peak = p[0]
+    max_depth = 0.0
+    duration = 0
+    cur_duration = 0
+    for price in p:
+        if price > peak:
+            peak = price
+            cur_duration = 0
+        else:
+            cur_duration += 1
+            dd = price / peak - 1
+            if dd < max_depth:
+                max_depth = dd
+        if cur_duration > duration:
+            duration = cur_duration
+    return max_depth, duration
+
+
+def ulcer_index(prices: Sequence[float]) -> float:
+    """Ulcer index of a price series."""
+    p = _to_list(prices)
+    if not p:
+        return 0.0
+    peak = p[0]
+    sum_sq = 0.0
+    for price in p:
+        if price > peak:
+            peak = price
+        dd = max(0.0, (peak - price) / peak)
+        sum_sq += dd ** 2
+    return sqrt(sum_sq / len(p))
+
+
+def ulcer_performance_index(prices: Sequence[float], risk_free_rate: float = 0.0, periods_per_year: int = 252) -> float:
+    """Ulcer Performance Index."""
+    ui = ulcer_index(prices)
+    if ui == 0:
+        return 0.0
+    return (cagr(prices, periods_per_year) - risk_free_rate) / ui
+
+
+def _parametric_stats(prices: Sequence[float]) -> Tuple[float, float]:
+    p = _to_list(prices)
+    if len(p) < 2:
+        return 0.0, 0.0
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mu = sum(rets) / len(rets)
+    var = sum((r - mu) ** 2 for r in rets) / len(rets)
+    return mu, sqrt(var)
+
+
+def parametric_var(prices: Sequence[float], level: float = 0.05) -> float:
+    """Parametric (normal) Value at Risk."""
+    mu, sigma = _parametric_stats(prices)
+    z = NormalDist().inv_cdf(level)
+    return -(mu + sigma * z)
+
+
+def parametric_expected_shortfall(prices: Sequence[float], level: float = 0.05) -> float:
+    """Parametric (normal) Expected Shortfall."""
+    mu, sigma = _parametric_stats(prices)
+    z = NormalDist().inv_cdf(level)
+    return -(mu - sigma * NormalDist().pdf(z) / level)
+
+
+def tail_ratio(prices: Sequence[float]) -> float:
+    """Tail ratio of returns (95th percentile over 5th percentile)."""
+    p = _to_list(prices)
+    if len(p) < 3:
+        return 0.0
+    rets = sorted(p[i] / p[i - 1] - 1 for i in range(1, len(p)))
+    n = len(rets)
+    q95 = rets[int(0.95 * (n - 1))]
+    q05 = rets[int(0.05 * (n - 1))]
+    if q05 == 0:
+        return 0.0
+    return abs(q95) / abs(q05)
+
+
+def sharpe_ratio(
+    prices: Sequence[float],
+    risk_free_rate: float = 0.0,
+    periods_per_year: int = 252,
+) -> float:
+    """Annualized Sharpe ratio of a price series."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return 0.0
+    rf_per = risk_free_rate / periods_per_year
+    rets = [p[i] / p[i - 1] - 1 - rf_per for i in range(1, len(p))]
+    mean = sum(rets) / len(rets)
+    var = sum((r - mean) ** 2 for r in rets) / len(rets)
+    if var == 0:
+        return 0.0
+    return mean / sqrt(var) * sqrt(periods_per_year)
+
+
+def sortino_ratio(
+    prices: Sequence[float],
+    risk_free_rate: float = 0.0,
+    periods_per_year: int = 252,
+) -> float:
+    """Annualized Sortino ratio of a price series."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return 0.0
+    rf_per = risk_free_rate / periods_per_year
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mean_excess = sum(r - rf_per for r in rets) / len(rets)
+    downside = [min(0.0, r - rf_per) for r in rets]
+    var = sum(d ** 2 for d in downside) / len(rets)
+    if var == 0:
+        return 0.0
+    return mean_excess / sqrt(var) * sqrt(periods_per_year)
+
+
+def calmar_ratio(prices: Sequence[float], periods_per_year: int = 252) -> float:
+    """Calmar ratio of a price series."""
+    mdd, _duration = max_drawdown(prices)
+    if mdd == 0:
+        return 0.0
+    return cagr(prices, periods_per_year) / abs(mdd)
+
+
+def omega_ratio(
+    prices: Sequence[float],
+    threshold: float = 0.0,
+    periods_per_year: int = 252,
+) -> float:
+    """Omega ratio of returns relative to a threshold."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return 0.0
+    thr = threshold / periods_per_year
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    gains = sum(max(r - thr, 0.0) for r in rets)
+    losses = sum(max(thr - r, 0.0) for r in rets)
+    if losses == 0:
+        return 0.0
+    return gains / losses
+
+
+def information_ratio(
+    prices: Sequence[float],
+    benchmark: Sequence[float],
+    periods_per_year: int = 252,
+) -> float:
+    """Information ratio of strategy vs. benchmark prices."""
+    p = _to_list(prices)
+    b = _to_list(benchmark)
+    n = min(len(p), len(b))
+    if n < 2:
+        return 0.0
+    strat_rets = [p[i] / p[i - 1] - 1 for i in range(1, n)]
+    bench_rets = [b[i] / b[i - 1] - 1 for i in range(1, n)]
+    active = [r - br for r, br in zip(strat_rets, bench_rets)]
+    mean = sum(active) / len(active)
+    var = sum((a - mean) ** 2 for a in active) / len(active)
+    if var == 0:
+        return 0.0
+    return mean / sqrt(var) * sqrt(periods_per_year)
+
+
+def capm_alpha_beta(prices: Sequence[float], benchmark: Sequence[float]) -> Tuple[float, float]:
+    """CAPM alpha and beta relative to a benchmark."""
+    p = _to_list(prices)
+    b = _to_list(benchmark)
+    n = min(len(p), len(b))
+    if n < 2:
+        return 0.0, 0.0
+    strat = [p[i] / p[i - 1] - 1 for i in range(1, n)]
+    bench = [b[i] / b[i - 1] - 1 for i in range(1, n)]
+    mean_x = sum(bench) / len(bench)
+    mean_y = sum(strat) / len(strat)
+    cov = sum((x - mean_x) * (y - mean_y) for x, y in zip(bench, strat)) / len(bench)
+    var_x = sum((x - mean_x) ** 2 for x in bench) / len(bench)
+    beta = cov / var_x if var_x else 0.0
+    alpha = mean_y - beta * mean_x
+    return alpha, beta
+
+
+def _invert_matrix(matrix: Sequence[Sequence[float]]) -> Sequence[Sequence[float]] | None:
+    size = len(matrix)
+    aug = [list(row) + [1 if i == j else 0 for j in range(size)] for i, row in enumerate(matrix)]
+    for i in range(size):
+        pivot = aug[i][i]
+        if abs(pivot) < 1e-12:
+            swap = next((j for j in range(i + 1, size) if abs(aug[j][i]) > 1e-12), None)
+            if swap is None:
+                return None
+            aug[i], aug[swap] = aug[swap], aug[i]
+            pivot = aug[i][i]
+        inv_p = 1 / pivot
+        for j in range(2 * size):
+            aug[i][j] *= inv_p
+        for k in range(size):
+            if k != i:
+                factor = aug[k][i]
+                for j in range(2 * size):
+                    aug[k][j] -= factor * aug[i][j]
+    return [row[size:] for row in aug]
+
+
+def _ols(y: Sequence[float], X: Sequence[Sequence[float]]) -> Sequence[float]:
+    n = len(y)
+    k = len(X[0]) if X else 0
+    xtx = [[0.0 for _ in range(k)] for _ in range(k)]
+    xty = [0.0 for _ in range(k)]
+    for i in range(n):
+        for p in range(k):
+            xty[p] += X[i][p] * y[i]
+            for q in range(k):
+                xtx[p][q] += X[i][p] * X[i][q]
+    inv = _invert_matrix(xtx)
+    if inv is None:
+        return [0.0 for _ in range(k)]
+    beta = [sum(inv[i][j] * xty[j] for j in range(k)) for i in range(k)]
+    return beta
+
+
+def fama_french_regression(prices: Sequence[float], factors: 'pd.DataFrame', factor_cols: Sequence[str]) -> 'pd.Series':  # type: ignore
+    """Run regression of excess returns on Fama-French factors."""
+    if pd is None:
+        raise ImportError("pandas is required for fama_french_regression")
+
+    p = _to_list(prices)
+    n = min(len(p), len(factors))
+    if n < 2:
+        data = [0.0] * (len(factor_cols) + 1)
+        s = pd.Series(data)
+        s.index = ["alpha"] + list(factor_cols)
+        return s
+
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, n)]
+    rf = _to_list(factors["RF"]) if "RF" in factors.columns else [0.0] * n
+    y = [rets[i - 1] - rf[i] for i in range(1, n)]
+    x = [[1.0] + [_to_list(factors[c])[i] for c in factor_cols] for i in range(1, n)]
+    beta = _ols(y, x)
+    s = pd.Series(beta)
+    s.index = ["alpha"] + list(factor_cols)
+    return s
+
+
+def fama_french_3factor(prices: Sequence[float], factors: 'pd.DataFrame') -> 'pd.Series':  # type: ignore
+    cols = [c for c in ["Mkt-RF", "SMB", "HML"] if c in getattr(factors, "columns", [])]
+    return fama_french_regression(prices, factors, cols)
+
+
+def fama_french_5factor(prices: Sequence[float], factors: 'pd.DataFrame') -> 'pd.Series':  # type: ignore
+    cols = [c for c in ["Mkt-RF", "SMB", "HML", "RMW", "CMA"] if c in getattr(factors, "columns", [])]
+    return fama_french_regression(prices, factors, cols)
+
+
+def cumulative_excess_return(prices: Sequence[float], benchmark: Sequence[float]) -> 'pd.Series':  # type: ignore
+    """Cumulative excess return of strategy versus a benchmark."""
+    if pd is None:
+        raise ImportError("pandas is required for cumulative_excess_return")
+
+    p = _to_list(prices)
+    b = _to_list(benchmark)
+    n = min(len(p), len(b))
+    index = list(getattr(prices, 'index', range(len(p))))[:n]
+    cum = []
+    total = 1.0
+    for i in range(n):
+        if i == 0:
+            cum.append(0.0)
+        else:
+            strat_ret = p[i] / p[i - 1] - 1
+            bench_ret = b[i] / b[i - 1] - 1
+            total *= 1 + (strat_ret - bench_ret)
+            cum.append(total - 1)
+    s = pd.Series(cum)
+    s.index = index
+    return s
+
+
+def skewness(prices: Sequence[float]) -> float:
+    """Skewness of returns of a price series."""
+    p = _to_list(prices)
+    if len(p) < 3:
+        return 0.0
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mean = sum(rets) / len(rets)
+    var = sum((r - mean) ** 2 for r in rets) / len(rets)
+    if var == 0:
+        return 0.0
+    std = sqrt(var)
+    m3 = sum((r - mean) ** 3 for r in rets) / len(rets)
+    return m3 / (std ** 3)
+
+
+def kurtosis(prices: Sequence[float]) -> float:
+    """Kurtosis of returns of a price series."""
+    p = _to_list(prices)
+    if len(p) < 3:
+        return 0.0
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mean = sum(rets) / len(rets)
+    var = sum((r - mean) ** 2 for r in rets) / len(rets)
+    if var == 0:
+        return 0.0
+    m4 = sum((r - mean) ** 4 for r in rets) / len(rets)
+    return m4 / (var ** 2)
+
+
+def variance_ratio(prices: Sequence[float], lag: int = 2) -> float:
+    """Lo-MacKinlay variance ratio test statistic."""
+    p = _to_list(prices)
+    if len(p) <= lag:
+        return 0.0
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mean = sum(rets) / len(rets)
+    var = sum((r - mean) ** 2 for r in rets) / len(rets)
+    if var == 0:
+        return 0.0
+    agg = [sum(rets[i - j] for j in range(1, lag + 1)) for i in range(lag, len(rets))]
+    var_lag = sum((a - lag * mean) ** 2 for a in agg) / len(agg)
+    return var_lag / (var * lag)
+
+
+def acf(prices: Sequence[float], lags: Sequence[int]) -> list[float]:
+    """Autocorrelation of returns for specified lags."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return [0.0 for _ in lags]
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    mean = sum(rets) / len(rets)
+    var = sum((r - mean) ** 2 for r in rets) / len(rets)
+    if var == 0:
+        return [0.0 for _ in lags]
+    out = []
+    for lag in lags:
+        if lag <= 0 or lag >= len(rets):
+            out.append(0.0)
+        else:
+            cov = sum((rets[i] - mean) * (rets[i - lag] - mean) for i in range(lag, len(rets))) / (len(rets) - lag)
+            out.append(cov / var)
+    return out
+
+
+def pacf(prices: Sequence[float], lags: Sequence[int]) -> list[float]:
+    """Partial autocorrelation of returns for specified lags."""
+    p = _to_list(prices)
+    if len(p) < 2:
+        return [0.0 for _ in lags]
+    rets = [p[i] / p[i - 1] - 1 for i in range(1, len(p))]
+    out = []
+    for k in lags:
+        if k <= 0 or k >= len(rets):
+            out.append(0.0)
+            continue
+        y = [rets[i] for i in range(k, len(rets))]
+        X = [[1.0] + [rets[i - j - 1] for j in range(k)] for i in range(k, len(rets))]
+        beta = _ols(y, X)
+        out.append(beta[-1] if beta else 0.0)
+    return out

pwb_toolbox/performance/plots.py

@@ -0,0 +1,415 @@
+import matplotlib.pyplot as plt
+from statistics import NormalDist
+
+try:
+    import pandas as pd  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - optional dependency
+    pd = None  # type: ignore
+
+from .metrics import (
+    _to_list,
+    returns_table,
+    annualized_volatility,
+    parametric_var,
+    sharpe_ratio,
+    sortino_ratio,
+    skewness,
+    kurtosis,
+    cumulative_excess_return,
+    fama_french_3factor,
+)
+
+
+def plot_equity_curve(prices, logy: bool = True, ax=None):
+    """Plot cumulative return equity curve."""
+    if ax is None:
+        fig, ax = plt.subplots()
+    p = _to_list(prices)
+    cum = [v / p[0] for v in p]
+    ax.plot(getattr(prices, 'index', range(len(p))), cum)
+    if logy:
+        ax.set_yscale('log')
+    ax.set_xlabel('Date')
+    ax.set_ylabel('Cumulative Return')
+    return ax
+
+
+def plot_return_heatmap(prices, ax=None):
+    """Plot calendar heatmap of returns from price series."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_return_heatmap")
+    tbl = returns_table(prices)
+    if ax is None:
+        fig, ax = plt.subplots()
+    data = [tbl[m].values for m in tbl.columns if m != 'Year']
+    im = ax.imshow(data, aspect='auto', interpolation='none',
+                   cmap='RdYlGn',
+                   vmin=min((min(filter(None, row)) for row in data if any(row))),
+                   vmax=max((max(filter(None, row)) for row in data if any(row))))
+    ax.set_yticks(range(len(tbl.index)))
+    ax.set_yticklabels(tbl.index)
+    ax.set_xticks(range(len(tbl.columns)-1))
+    ax.set_xticklabels([c for c in tbl.columns if c != 'Year'])
+    plt.colorbar(im, ax=ax)
+    return ax
+
+
+def plot_underwater(prices, ax=None):
+    """Plot drawdown (underwater) chart."""
+    if ax is None:
+        fig, ax = plt.subplots()
+    p = _to_list(prices)
+    peak = p[0] if p else 0
+    dd = []
+    for price in p:
+        if price > peak:
+            peak = price
+        dd.append(price / peak - 1)
+    ax.plot(getattr(prices, 'index', range(len(p))), dd)
+    ax.set_ylabel('Drawdown')
+    ax.set_xlabel('Date')
+    return ax
+
+
+def plot_rolling_volatility(prices, window: int = 63, periods_per_year: int = 252, ax=None):
+    """Plot rolling annualized volatility."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_rolling_volatility")
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    vols = []
+    for i in range(len(p)):
+        if i < window:
+            vols.append(None)
+        else:
+            vols.append(annualized_volatility(p[i - window:i + 1], periods_per_year))
+    s = pd.Series(vols)
+    s.index = index
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(s.index, s)
+    ax.set_ylabel('Volatility')
+    ax.set_xlabel('Date')
+    return ax
+
+
+def plot_rolling_var(prices, window: int = 63, level: float = 0.05, ax=None):
+    """Plot rolling parametric VaR."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_rolling_var")
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    vars_ = []
+    for i in range(len(p)):
+        if i < window:
+            vars_.append(None)
+        else:
+            vars_.append(parametric_var(p[i - window:i + 1], level))
+    s = pd.Series(vars_)
+    s.index = index
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(s.index, s)
+    ax.set_ylabel('VaR')
+    ax.set_xlabel('Date')
+    return ax
+
+
+def plot_rolling_sharpe(
+    prices,
+    window: int = 63,
+    risk_free_rate: float = 0.0,
+    periods_per_year: int = 252,
+    ax=None,
+):
+    """Plot rolling Sharpe ratio."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_rolling_sharpe")
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    vals = []
+    for i in range(len(p)):
+        if i < window:
+            vals.append(None)
+        else:
+            vals.append(
+                sharpe_ratio(p[i - window : i + 1], risk_free_rate, periods_per_year)
+            )
+    s = pd.Series(vals)
+    s.index = index
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(s.index, s)
+    ax.set_ylabel('Sharpe')
+    ax.set_xlabel('Date')
+    return ax
+
+
+def plot_rolling_sortino(
+    prices,
+    window: int = 63,
+    risk_free_rate: float = 0.0,
+    periods_per_year: int = 252,
+    ax=None,
+):
+    """Plot rolling Sortino ratio."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_rolling_sortino")
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    vals = []
+    for i in range(len(p)):
+        if i < window:
+            vals.append(None)
+        else:
+            vals.append(
+                sortino_ratio(p[i - window : i + 1], risk_free_rate, periods_per_year)
+            )
+    s = pd.Series(vals)
+    s.index = index
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(s.index, s)
+    ax.set_ylabel('Sortino')
+    ax.set_xlabel('Date')
+    return ax
+
+
+def plot_return_scatter(prices, benchmark_prices, ax=None):
+    """Scatter of strategy vs benchmark returns with regression line."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_return_scatter")
+    p = _to_list(prices)
+    b = _to_list(benchmark_prices)
+    n = min(len(p), len(b))
+    if n < 2:
+        raise ValueError("insufficient data")
+    strat = [p[i] / p[i - 1] - 1 for i in range(1, n)]
+    bench = [b[i] / b[i - 1] - 1 for i in range(1, n)]
+    mean_x = sum(bench) / len(bench)
+    mean_y = sum(strat) / len(strat)
+    cov = sum((x - mean_x) * (y - mean_y) for x, y in zip(bench, strat)) / len(bench)
+    var_x = sum((x - mean_x) ** 2 for x in bench) / len(bench)
+    beta = cov / var_x if var_x else 0.0
+    alpha = mean_y - beta * mean_x
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.scatter(bench, strat, s=10)
+    xs = [min(bench), max(bench)]
+    ys = [alpha + beta * x for x in xs]
+    ax.plot(xs, ys, color='red', label=f"alpha={alpha:.2f}, beta={beta:.2f}")
+    ax.set_xlabel('Benchmark Return')
+    ax.set_ylabel('Strategy Return')
+    ax.legend()
+    return ax
+
+
+def plot_cumulative_excess_return(prices, benchmark_prices, ax=None):
+    """Plot cumulative excess return versus benchmark."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_cumulative_excess_return")
+    ser = cumulative_excess_return(prices, benchmark_prices)
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(ser.index, ser)
+    ax.set_ylabel("Cumulative Excess Return")
+    ax.set_xlabel("Date")
+    return ax
+
+
+def plot_factor_exposures(prices, factors, ax=None):
+    """Bar chart of Fama-French 3 factor exposures."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_factor_exposures")
+    exp = fama_french_3factor(prices, factors)
+    names = [n for n in exp.index if n != "alpha"]
+    vals = [exp[n] for n in names]
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.bar(range(len(vals)), vals)
+    ax.set_xticks(range(len(names)))
+    ax.set_xticklabels(names, rotation=45)
+    ax.set_ylabel("Exposure")
+    return ax
+
+
+def plot_trade_return_hist(trades, ax=None, bins=20):
+    """Histogram of trade returns for long and short trades."""
+    if ax is None:
+        fig, ax = plt.subplots()
+    longs = [t.get("return", 0) for t in trades if t.get("direction") == "long"]
+    shorts = [t.get("return", 0) for t in trades if t.get("direction") == "short"]
+    if longs:
+        ax.hist(longs, bins=bins, alpha=0.5, label="Long")
+    if shorts:
+        ax.hist(shorts, bins=bins, alpha=0.5, label="Short")
+    ax.set_xlabel("Trade Return")
+    ax.set_ylabel("Frequency")
+    if longs or shorts:
+        ax.legend()
+    return ax
+
+
+def plot_return_by_holding_period(trades, ax=None):
+    """Box plot of trade return grouped by holding period."""
+    if ax is None:
+        fig, ax = plt.subplots()
+    groups = {}
+    for t in trades:
+        entry = t.get("entry")
+        exit_ = t.get("exit")
+        if entry is None or exit_ is None:
+            continue
+        dur = (exit_ - entry).days if hasattr(exit_ - entry, "days") else int(exit_ - entry)
+        groups.setdefault(dur, []).append(t.get("return", 0))
+    if not groups:
+        return ax
+    durations = sorted(groups)
+    data = [groups[d] for d in durations]
+    ax.boxplot(data, positions=range(len(data)))
+    ax.set_xticks(range(len(data)))
+    ax.set_xticklabels([str(d) for d in durations])
+    ax.set_xlabel("Holding Period (days)")
+    ax.set_ylabel("Return")
+    return ax
+
+
+def plot_exposure_ts(trades, ax=None):
+    """Time series of gross and net exposure based on open trades."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_exposure_ts")
+    entries = [t.get("entry") for t in trades if t.get("entry") is not None]
+    exits = [t.get("exit") for t in trades if t.get("exit") is not None]
+    if not entries or not exits:
+        if ax is None:
+            fig, ax = plt.subplots()
+        return ax
+    start = min(entries)
+    end = max(exits)
+    idx = pd.date_range(start, end)
+    gross = [0.0 for _ in idx]
+    net = [0.0 for _ in idx]
+    for t in trades:
+        entry = t.get("entry")
+        exit_ = t.get("exit")
+        size = t.get("size", 0.0)
+        if entry is None or exit_ is None:
+            continue
+        for i, date in enumerate(idx):
+            if entry <= date <= exit_:
+                gross[i] += abs(size)
+                net[i] += size
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(idx, gross, label="Gross")
+    ax.plot(idx, net, label="Net")
+    ax.set_ylabel("Exposure")
+    ax.set_xlabel("Date")
+    ax.legend()
+    return ax
+
+
+def plot_cumulative_shortfall(trades, ax=None):
+    """Plot cumulative implementation shortfall over time."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_cumulative_shortfall")
+
+    from .trade_stats import trade_implementation_shortfall
+
+    dates = []
+    cum = []
+    total = 0.0
+    for t in trades:
+        date = t.get("exit") or t.get("entry")
+        total += trade_implementation_shortfall(t)
+        dates.append(date)
+        cum.append(total)
+
+    ser = pd.Series(cum, index=dates)
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(ser.index, ser)
+    ax.set_ylabel("Cumulative Shortfall")
+    ax.set_xlabel("Date")
+    return ax
+
+
+def plot_alpha_vs_return(trades, ax=None):
+    """Scatter plot of forecasted alpha versus realised trade return."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_alpha_vs_return")
+
+    alphas = [t.get("forecast_alpha") for t in trades if t.get("forecast_alpha") is not None]
+    rets = [t.get("return") for t in trades if t.get("forecast_alpha") is not None]
+
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.scatter(alphas, rets, s=10)
+    ax.set_xlabel("Forecast Alpha")
+    ax.set_ylabel("Realized Return")
+    return ax
+
+
+def plot_qq_returns(prices, ax=None):
+    """QQ-plot of returns versus normal distribution."""
+    if ax is None:
+        fig, ax = plt.subplots()
+    p = _to_list(prices)
+    if len(p) < 2:
+        return ax
+    rets = sorted(p[i] / p[i - 1] - 1 for i in range(1, len(p)))
+    n = len(rets)
+    mean = sum(rets) / n
+    var = sum((r - mean) ** 2 for r in rets) / n
+    std = var ** 0.5
+    dist = NormalDist(mean, std)
+    qs = [(i + 0.5) / n for i in range(n)]
+    theo = [dist.inv_cdf(q) for q in qs]
+    ax.scatter(theo, rets, s=10)
+    ax.set_xlabel("Theoretical Quantiles")
+    ax.set_ylabel("Empirical Quantiles")
+    return ax
+
+
+def plot_rolling_skewness(prices, window: int = 63, ax=None):
+    """Plot rolling skewness of returns."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_rolling_skewness")
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    vals = []
+    for i in range(len(p)):
+        if i < window:
+            vals.append(None)
+        else:
+            vals.append(skewness(p[i - window : i + 1]))
+    s = pd.Series(vals)
+    s.index = index
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(s.index, s)
+    ax.set_ylabel("Skewness")
+    ax.set_xlabel("Date")
+    return ax
+
+
+def plot_rolling_kurtosis(prices, window: int = 63, ax=None):
+    """Plot rolling kurtosis of returns."""
+    if pd is None:
+        raise ImportError("pandas is required for plot_rolling_kurtosis")
+    p = _to_list(prices)
+    index = list(getattr(prices, 'index', range(len(p))))
+    vals = []
+    for i in range(len(p)):
+        if i < window:
+            vals.append(None)
+        else:
+            vals.append(kurtosis(p[i - window : i + 1]))
+    s = pd.Series(vals)
+    s.index = index
+    if ax is None:
+        fig, ax = plt.subplots()
+    ax.plot(s.index, s)
+    ax.set_ylabel("Kurtosis")
+    ax.set_xlabel("Date")
+    return ax

pwb_toolbox/performance/trade_stats.py

@@ -0,0 +1,138 @@
+from collections import Counter
+from datetime import datetime
+from typing import Mapping, Sequence, Tuple, Any, Dict, List
+
+
+def hit_rate(trades: Sequence[Mapping[str, Any]]) -> float:
+    """Proportion of trades with positive return."""
+    if not trades:
+        return 0.0
+    wins = sum(1 for t in trades if t.get("return", 0) > 0)
+    return wins / len(trades)
+
+
+def average_win_loss(trades: Sequence[Mapping[str, Any]]) -> Tuple[float, float]:
+    """Average winning and losing trade returns."""
+    wins = [t.get("return", 0) for t in trades if t.get("return", 0) > 0]
+    losses = [t.get("return", 0) for t in trades if t.get("return", 0) < 0]
+    avg_win = sum(wins) / len(wins) if wins else 0.0
+    avg_loss = sum(losses) / len(losses) if losses else 0.0
+    return avg_win, avg_loss
+
+
+def expectancy(trades: Sequence[Mapping[str, Any]]) -> float:
+    """Expected return per trade."""
+    hr = hit_rate(trades)
+    avg_win, avg_loss = average_win_loss(trades)
+    return hr * avg_win + (1 - hr) * avg_loss
+
+
+def profit_factor(trades: Sequence[Mapping[str, Any]]) -> float:
+    """Ratio of gross profits to gross losses."""
+    gains = sum(t.get("return", 0) for t in trades if t.get("return", 0) > 0)
+    losses = -sum(t.get("return", 0) for t in trades if t.get("return", 0) < 0)
+    if losses == 0:
+        return float("inf") if gains > 0 else 0.0
+    return gains / losses
+
+
+def trade_duration_distribution(trades: Sequence[Mapping[str, Any]]) -> Dict[int, int]:
+    """Distribution of trade holding periods in days."""
+    durations = []
+    for t in trades:
+        entry = t.get("entry")
+        exit_ = t.get("exit")
+        if entry is None or exit_ is None:
+            continue
+        delta = exit_ - entry
+        days = delta.days if hasattr(delta, "days") else int(delta)
+        durations.append(days)
+    return dict(Counter(durations))
+
+
+def turnover(trades: Sequence[Mapping[str, Any]]) -> float:
+    """Average number of trades per day."""
+    if not trades:
+        return 0.0
+    entries = [t.get("entry") for t in trades if t.get("entry") is not None]
+    exits = [t.get("exit") for t in trades if t.get("exit") is not None]
+    if not entries or not exits:
+        return 0.0
+    start = min(entries)
+    end = max(exits)
+    period = (end - start).days
+    if period <= 0:
+        return float(len(trades))
+    return len(trades) / period
+
+
+def trade_implementation_shortfall(trade: Mapping[str, Any]) -> float:
+    """Implementation shortfall for a single trade.
+
+    Calculated as the difference between the modelled return and the
+    realised return of the trade.  If either value is missing the result
+    is ``0.0``.
+    """
+
+    model_ret = trade.get("model_return")
+    actual_ret = trade.get("return")
+    if model_ret is None or actual_ret is None:
+        return 0.0
+    return model_ret - actual_ret
+
+
+def cumulative_implementation_shortfall(trades: Sequence[Mapping[str, Any]]) -> float:
+    """Total implementation shortfall over a collection of trades."""
+
+    return sum(trade_implementation_shortfall(t) for t in trades)
+
+
+def slippage_stats(trades: Sequence[Mapping[str, Any]]) -> Dict[str, float]:
+    """Average entry and exit slippage for a set of trades.
+
+    Slippage is measured relative to the model prices.  Positive values
+    indicate worse execution than the modelled price.
+    """
+
+    entry_slip: List[float] = []
+    exit_slip: List[float] = []
+
+    for t in trades:
+        direction = 1 if t.get("direction") == "long" else -1
+
+        if "entry_price" in t and "model_entry_price" in t and t["model_entry_price"]:
+            entry_slip.append(
+                direction
+                * (t["entry_price"] - t["model_entry_price"]) / t["model_entry_price"]
+            )
+
+        if "exit_price" in t and "model_exit_price" in t and t["model_exit_price"]:
+            exit_slip.append(
+                direction
+                * (t["model_exit_price"] - t["exit_price"]) / t["model_exit_price"]
+            )
+
+    avg_entry = sum(entry_slip) / len(entry_slip) if entry_slip else 0.0
+    avg_exit = sum(exit_slip) / len(exit_slip) if exit_slip else 0.0
+    return {"avg_entry_slippage": avg_entry, "avg_exit_slippage": avg_exit}
+
+
+def latency_stats(trades: Sequence[Mapping[str, Any]]) -> Dict[str, float]:
+    """Basic latency metrics in seconds between signal and execution."""
+
+    latencies = []
+    for t in trades:
+        signal_time = t.get("signal_time")
+        entry_time = t.get("entry")
+        if signal_time is None or entry_time is None:
+            continue
+        delta = entry_time - signal_time
+        secs = delta.total_seconds() if hasattr(delta, "total_seconds") else float(delta)
+        latencies.append(secs)
+
+    if not latencies:
+        return {"avg_latency_sec": 0.0, "max_latency_sec": 0.0}
+
+    avg_lat = sum(latencies) / len(latencies)
+    max_lat = max(latencies)
+    return {"avg_latency_sec": avg_lat, "max_latency_sec": max_lat}

{pwb_toolbox-0.1.7.dist-info → pwb_toolbox-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pwb-toolbox
-Version: 0.1.7
+Version: 0.1.8
 Summary: A toolbox library for quant traders
 Home-page: https://github.com/paperswithbacktest/pwb-toolbox
 Author: Your Name
@@ -16,6 +16,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: datasets
 Requires-Dist: pandas
+Requires-Dist: ibapi
+Requires-Dist: ib_insync
 Dynamic: license-file
 
 <div align="center">
@@ -128,10 +130,68 @@ into portfolio weights and executed via Backtrader orders.
 ```python
 from pwb_toolbox.backtest.examples import GoldenCrossAlpha, EqualWeightPortfolio
 from pwb_toolbox.backtest import run_backtest
+from pwb_toolbox.backtest.execution_models import ImmediateExecutionModel
+from pwb_toolbox.backtest.risk_models import MaximumTotalPortfolioExposure
+from pwb_toolbox.backtest.universe_models import ManualUniverseSelectionModel
+
+run_backtest(
+    ManualUniverseSelectionModel(["SPY", "QQQ"]),
+    GoldenCrossAlpha(),
+    EqualWeightPortfolio(),
+    execution=ImmediateExecutionModel(),
+    risk=MaximumTotalPortfolioExposure(max_exposure=1.0),
+    start="2015-01-01",
+)
+```
+
+## Performance Analysis
+
+After running a backtest you can analyze the returned equity series using the
+`pwb_toolbox.performance` module.
+
+```python
+from pwb_toolbox.backtest.examples import GoldenCrossAlpha, EqualWeightPortfolio
+from pwb_toolbox.backtest import run_backtest
+from pwb_toolbox.backtest.execution_models import ImmediateExecutionModel
+from pwb_toolbox.performance import total_return, cagr
+from pwb_toolbox.performance.plots import plot_equity_curve
+
+result, equity = run_backtest(
+    ManualUniverseSelectionModel(["SPY", "QQQ"]),
+    GoldenCrossAlpha(),
+    EqualWeightPortfolio(),
+    execution=ImmediateExecutionModel(),
+    start="2015-01-01",
+)
 
-run_backtest(["SPY", "QQQ"], GoldenCrossAlpha(), EqualWeightPortfolio(), start="2015-01-01")
+print("Total return:", total_return(equity))
+print("CAGR:", cagr(equity))
+
+plot_equity_curve(equity)
 ```
 
+Plotting utilities require `matplotlib`; some metrics also need `pandas`.
+
+## Live trading with Interactive Brokers
+
+`run_ib_strategy` streams Interactive Brokers data and orders. Install `ibapi` and either `atreyu-backtrader-api` or `ib_insync`.
+
+```python
+from pwb_toolbox.backtest import IBConnector, run_ib_strategy
+from pwb_toolbox.backtest.example.engine import SimpleIBStrategy
+
+data_cfg = [{"dataname": "AAPL", "name": "AAPL"}]
+run_ib_strategy(
+    SimpleIBStrategy,
+    data_cfg,
+    host="127.0.0.1",
+    port=7497,
+    client_id=1,
+)
+```
+
+Configure `host`, `port`, and `client_id` to match your TWS or Gateway settings. Test with an Interactive Brokers paper account before trading live.
+
 ## Contributing
 
 Contributions to the `pwb-toolbox` package are welcome! If you have any improvements, new datasets, or strategy ideas to share, please follow these guidelines:

pwb_toolbox-0.1.8.dist-info/RECORD

@@ -0,0 +1,19 @@
+pwb_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pwb_toolbox/backtest/__init__.py,sha256=uXP0toenQFhIOn8uwyoKNRjH1bEyVfO0-ryFZAMb1xE,2066
+pwb_toolbox/backtest/base_strategy.py,sha256=PQTO9vytnxeDplmaDUC8ORYwo9dTUbwhNrrmHlpDAAU,994
+pwb_toolbox/backtest/ib_connector.py,sha256=5T-pgT_MrDOxqdvXgT_hceIeewPs-rN3j4n-Wr-6JGU,2120
+pwb_toolbox/backtest/insight.py,sha256=NPrNr7ToNUpqHvgOjgtsP1g8p1Pn8yXuD6YSO-zYePg,394
+pwb_toolbox/backtest/execution_models/__init__.py,sha256=kMa-C7DPeCwB81pyOp3gjIUSYpI3EuCn1uO9vLTJK4Q,5996
+pwb_toolbox/backtest/portfolio_models/__init__.py,sha256=VDDDOUhu4kPxYJsOb9dH-qHTfM-Hj8O7hmzLXGuSxs8,9353
+pwb_toolbox/backtest/risk_models/__init__.py,sha256=Sbd4CeGGhxRFQfdsiMoL7ws-1NJq6IkhxQhXAnGacpY,6319
+pwb_toolbox/backtest/universe_models/__init__.py,sha256=-NXd_dhPKHgfBpynWjKJ4YxHLvagNhNPfU_JUreK7fc,5715
+pwb_toolbox/datasets/__init__.py,sha256=o2Q6nw8HmV_gTFfovhPJkoGdFsADBunFC4KqBl9Tpaw,22259
+pwb_toolbox/performance/__init__.py,sha256=ds47RiOSL3iIwRE0S8dnGINcVPlZw_I9D21ueTSVP-I,2925
+pwb_toolbox/performance/metrics.py,sha256=szY8m45dZeJHciF4NxPxXlDyc78_5cLyIweRQJ_8lCE,15255
+pwb_toolbox/performance/plots.py,sha256=R6OV-SxJaJnBuJGh8XmsF58a7ERwn2Irf4zEqzGMRz4,12886
+pwb_toolbox/performance/trade_stats.py,sha256=I-iboKMwVLij6pc2r-KfNDnyF3LZV_LzzpgjIcJtgFw,4940
+pwb_toolbox-0.1.8.dist-info/licenses/LICENSE.txt,sha256=_Wjz7o7St3iVSPBRzE0keS8XSqSJ03A3NZ6cMlTaSK8,1079
+pwb_toolbox-0.1.8.dist-info/METADATA,sha256=tVOCTxHNoDRAXG1mzp2NVzUn92OMQmwtwx2RUv7mWJU,7130
+pwb_toolbox-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pwb_toolbox-0.1.8.dist-info/top_level.txt,sha256=TZcXcF2AMkKkibZOuq6AYsHjajPgddHAGjQUT64OYGY,12
+pwb_toolbox-0.1.8.dist-info/RECORD,,

pwb_toolbox-0.1.7.dist-info/RECORD

@@ -1,14 +0,0 @@
-pwb_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwb_toolbox/backtest/__init__.py,sha256=PnyGN0ZF2Apc1yPxQPHEAE7OtEvMza63zZqJPJTyIAg,1868
-pwb_toolbox/backtest/base_strategy.py,sha256=PQTO9vytnxeDplmaDUC8ORYwo9dTUbwhNrrmHlpDAAU,994
-pwb_toolbox/backtest/insight.py,sha256=NPrNr7ToNUpqHvgOjgtsP1g8p1Pn8yXuD6YSO-zYePg,394
-pwb_toolbox/backtest/execution_models/__init__.py,sha256=kMa-C7DPeCwB81pyOp3gjIUSYpI3EuCn1uO9vLTJK4Q,5996
-pwb_toolbox/backtest/portfolio_models/__init__.py,sha256=VDDDOUhu4kPxYJsOb9dH-qHTfM-Hj8O7hmzLXGuSxs8,9353
-pwb_toolbox/backtest/risk_models/__init__.py,sha256=Sbd4CeGGhxRFQfdsiMoL7ws-1NJq6IkhxQhXAnGacpY,6319
-pwb_toolbox/backtest/universe_models/__init__.py,sha256=-NXd_dhPKHgfBpynWjKJ4YxHLvagNhNPfU_JUreK7fc,5715
-pwb_toolbox/datasets/__init__.py,sha256=3TnI0mcjJywvkKbUdQ-dahD0Py7fjna7lG9cv07vGMg,22259
-pwb_toolbox-0.1.7.dist-info/licenses/LICENSE.txt,sha256=_Wjz7o7St3iVSPBRzE0keS8XSqSJ03A3NZ6cMlTaSK8,1079
-pwb_toolbox-0.1.7.dist-info/METADATA,sha256=wgpnREqh2IhIP7TOmAfkzznrXj-TNs-tzyPV-i1Xwoo,5237
-pwb_toolbox-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pwb_toolbox-0.1.7.dist-info/top_level.txt,sha256=TZcXcF2AMkKkibZOuq6AYsHjajPgddHAGjQUT64OYGY,12
-pwb_toolbox-0.1.7.dist-info/RECORD,,