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

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.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pwb-toolbox
-Version: 0.1.7
+Version: 0.1.9
 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.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+pwb_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pwb_toolbox/backtest/__init__.py,sha256=EDqoQ-P4ADV91F2oCgtSfFK1R_65BMVsFWDlk-zNHnM,128
+pwb_toolbox/backtest/base_strategy.py,sha256=aKQ7XNxWkljaR7TQ-Tbs_uNWBDLdbmaLADcCsclBwuU,990
+pwb_toolbox/backtest/engine.py,sha256=v5mO5HUhsQnxmBeSdkE0KwbYZnS6rB1TM_A3AYERa4s,1252
+pwb_toolbox/backtest/ib_connector.py,sha256=5T-pgT_MrDOxqdvXgT_hceIeewPs-rN3j4n-Wr-6JGU,2120
+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.9.dist-info/licenses/LICENSE.txt,sha256=_Wjz7o7St3iVSPBRzE0keS8XSqSJ03A3NZ6cMlTaSK8,1079
+pwb_toolbox-0.1.9.dist-info/METADATA,sha256=_Abqeq866im1F_F_x3iTEvV-Fg-QA0ri7d5xtAQ-NUk,7130
+pwb_toolbox-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pwb_toolbox-0.1.9.dist-info/top_level.txt,sha256=TZcXcF2AMkKkibZOuq6AYsHjajPgddHAGjQUT64OYGY,12
+pwb_toolbox-0.1.9.dist-info/RECORD,,