pwb-toolbox 0.1.8__tar.gz → 0.1.10__tar.gz

{pwb_toolbox-0.1.8 → pwb_toolbox-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pwb-toolbox
-Version: 0.1.8
+Version: 0.1.10
 Summary: A toolbox library for quant traders
 Home-page: https://github.com/paperswithbacktest/pwb-toolbox
 Author: Your Name

pwb_toolbox-0.1.10/pwb_toolbox/backtest/__init__.py

@@ -0,0 +1,5 @@
+from .base_strategy import BaseStrategy
+from .engine import run_strategy
+from .ib_connector import IBConnector, run_ib_strategy
+from .portfolio import MonthlyEqualWeightPortfolio
+from .universe import get_most_liquid_symbols, get_least_volatile_symbols

{pwb_toolbox-0.1.8 → pwb_toolbox-0.1.10}/pwb_toolbox/backtest/base_strategy.py

@@ -18,7 +18,7 @@ class BaseStrategy(bt.Strategy):
             return False
         return data.close[0] != data.close[-2]
 
-    def __next__(self):
+    def next(self):
         """Update progress bar and log current value."""
         self.pbar.update(1)
         self.log_data.append(

pwb_toolbox-0.1.10/pwb_toolbox/backtest/engine.py

@@ -0,0 +1,33 @@
+import backtrader as bt
+import pandas as pd
+import pwb_toolbox.datasets as pwb_ds
+
+
+def run_strategy(signal, signal_kwargs, portfolio, symbols, start_date, leverage, cash):
+    """Run a tactical asset allocation strategy with Backtrader."""
+    # Load the data from https://paperswithbacktest.com/datasets
+    pivot_df = pwb_ds.get_pricing(
+        symbol_list=symbols,
+        fields=["open", "high", "low", "close"],
+        start_date=start_date,
+        extend=True,  # Extend the dataset with proxy data
+    )
+    # Create trading-day index (optional but keeps Cerebro happy)
+    trading_days = pd.bdate_range(pivot_df.index.min(), pivot_df.index.max())
+    pivot_df = pivot_df.reindex(trading_days)
+    pivot_df.ffill(inplace=True)  # forward-fill holidays
+    pivot_df.bfill(inplace=True)  # back-fill leading IPO gaps
+    cerebro = bt.Cerebro()
+    for symbol in pivot_df.columns.levels[0]:
+        data = bt.feeds.PandasData(dataname=pivot_df[symbol].copy())
+        cerebro.adddata(data, name=symbol)
+    cerebro.addstrategy(
+        portfolio,
+        total_days=len(trading_days),
+        leverage=0.9,
+        signal_cls=signal,
+        signal_kwargs=signal_kwargs,
+    )
+    cerebro.broker.set_cash(cash)
+    strategy = cerebro.run()[0]
+    return strategy

pwb_toolbox-0.1.10/pwb_toolbox/backtest/portfolio.py

@@ -0,0 +1,30 @@
+from .base_strategy import BaseStrategy
+
+
+class MonthlyEqualWeightPortfolio(BaseStrategy):
+    params = (
+        ("leverage", 0.9),
+        ("signal_cls", None),
+        ("signal_kwargs", {}),
+    )
+
+    def __init__(self):
+        super().__init__()
+        self.sig = {
+            d._name: self.p.signal_cls(d, **self.p.signal_kwargs) for d in self.datas
+        }
+        self.last_month = -1
+
+    def next(self):
+        """Rebalance portfolio at the start of each month."""
+        super().next()
+        today = self.datas[0].datetime.date(0)
+        if today.month == self.last_month:
+            return
+        self.last_month = today.month
+        longs = [
+            d for d in self.datas if self.is_tradable(d) and self.sig[d._name][0] == 1
+        ]
+        wt = (self.p.leverage / len(longs)) if longs else 0.0
+        for d in self.datas:
+            self.order_target_percent(d, target=wt if d in longs else 0)

pwb_toolbox-0.1.10/pwb_toolbox/backtest/universe.py

@@ -0,0 +1,37 @@
+from typing import List
+import pandas as pd
+import pwb_toolbox.datasets as pwb_ds
+
+
+def get_most_liquid_symbols(n: int = 1_200) -> List[str]:
+    """Return the `n` most liquid stock symbols (volume × price on last bar)."""
+    df = pwb_ds.load_dataset("Stocks-Daily-Price", adjust=True, extend=True)
+    last_date = df["date"].max()
+    today = df[df["date"] == last_date].copy()
+    today["liquidity"] = today["volume"] * today["close"]
+    liquid = today.sort_values("liquidity", ascending=False)
+    return liquid["symbol"].tolist()[:n]
+
+
+def get_least_volatile_symbols(symbols=["sp500"], start="1990-01-01") -> List[str]:
+    pivot = pwb_ds.get_pricing(
+        symbol_list=symbols,
+        fields=["open", "high", "low", "close"],
+        start_date=start,
+        extend=True,
+    )
+    td = pd.bdate_range(pivot.index.min(), pivot.index.max())
+    pivot = pivot.reindex(td).ffill().bfill()
+    symbols = []
+    for sym in pivot.columns.levels[0]:
+        df = (
+            pivot[sym]
+            .copy()
+            .reset_index()
+            .rename(columns={"index": "date"})
+            .set_index("date")
+        )
+        if df.close.pct_change().abs().max() > 3:  # same volatility filter
+            continue
+        symbols.append(sym)
+    return symbols

{pwb_toolbox-0.1.8 → pwb_toolbox-0.1.10}/pwb_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pwb-toolbox
-Version: 0.1.8
+Version: 0.1.10
 Summary: A toolbox library for quant traders
 Home-page: https://github.com/paperswithbacktest/pwb-toolbox
 Author: Your Name

{pwb_toolbox-0.1.8 → pwb_toolbox-0.1.10}/pwb_toolbox.egg-info/SOURCES.txt

@@ -10,12 +10,10 @@ pwb_toolbox.egg-info/requires.txt
 pwb_toolbox.egg-info/top_level.txt
 pwb_toolbox/backtest/__init__.py
 pwb_toolbox/backtest/base_strategy.py
+pwb_toolbox/backtest/engine.py
 pwb_toolbox/backtest/ib_connector.py
-pwb_toolbox/backtest/insight.py
-pwb_toolbox/backtest/execution_models/__init__.py
-pwb_toolbox/backtest/portfolio_models/__init__.py
-pwb_toolbox/backtest/risk_models/__init__.py
-pwb_toolbox/backtest/universe_models/__init__.py
+pwb_toolbox/backtest/portfolio.py
+pwb_toolbox/backtest/universe.py
 pwb_toolbox/datasets/__init__.py
 pwb_toolbox/performance/__init__.py
 pwb_toolbox/performance/metrics.py

{pwb_toolbox-0.1.8 → pwb_toolbox-0.1.10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pwb-toolbox
-version = 0.1.8
+version = 0.1.10
 author = Your Name
 author_email = hello@paperswithbacktest.com
 description = A toolbox library for quant traders

pwb_toolbox-0.1.8/pwb_toolbox/backtest/__init__.py

@@ -1,57 +0,0 @@
-from .base_strategy import BaseStrategy
-
-from .insight import Direction, Insight
-
-from .portfolio_models import (
-    PortfolioConstructionModel,
-    EqualWeightingPortfolioConstructionModel,
-    InsightWeightingPortfolioConstructionModel,
-    MeanVarianceOptimizationPortfolioConstructionModel,
-    BlackLittermanOptimizationPortfolioConstructionModel,
-    RiskParityPortfolioConstructionModel,
-    UnconstrainedMeanVariancePortfolioConstructionModel,
-    TargetPercentagePortfolioConstructionModel,
-    DollarCostAveragingPortfolioConstructionModel,
-    InsightRatioPortfolioConstructionModel,
-)
-from .ib_connector import IBConnector, run_ib_strategy
-from .example.engine import run_backtest, run_ib_backtest
-
-__all__ = [
-    "Direction",
-    "Insight",
-    "PortfolioConstructionModel",
-    "EqualWeightingPortfolioConstructionModel",
-    "InsightWeightingPortfolioConstructionModel",
-    "MeanVarianceOptimizationPortfolioConstructionModel",
-    "BlackLittermanOptimizationPortfolioConstructionModel",
-    "RiskParityPortfolioConstructionModel",
-    "UnconstrainedMeanVariancePortfolioConstructionModel",
-    "TargetPercentagePortfolioConstructionModel",
-    "DollarCostAveragingPortfolioConstructionModel",
-    "InsightRatioPortfolioConstructionModel",
-    "RiskManagementModel",
-    "TrailingStopRiskManagementModel",
-    "MaximumDrawdownPercentPerSecurity",
-    "MaximumDrawdownPercentPortfolio",
-    "MaximumUnrealizedProfitPercentPerSecurity",
-    "MaximumTotalPortfolioExposure",
-    "SectorExposureRiskManagementModel",
-    "MaximumOrderQuantityPercentPerSecurity",
-    "CompositeRiskManagementModel",
-    "IBConnector",
-    "run_ib_strategy",
-    "run_backtest",
-    "run_ib_backtest",
-]
-from .risk_models import (
-    RiskManagementModel,
-    TrailingStopRiskManagementModel,
-    MaximumDrawdownPercentPerSecurity,
-    MaximumDrawdownPercentPortfolio,
-    MaximumUnrealizedProfitPercentPerSecurity,
-    MaximumTotalPortfolioExposure,
-    SectorExposureRiskManagementModel,
-    MaximumOrderQuantityPercentPerSecurity,
-    CompositeRiskManagementModel,
-)

pwb_toolbox-0.1.8/pwb_toolbox/backtest/execution_models/__init__.py

@@ -1,153 +0,0 @@
-"""Execution models for order placement using Backtrader."""
-
-from __future__ import annotations
-
-from typing import Dict
-import backtrader as bt
-
-
-class ExecutionModel:
-    """Base execution model class."""
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        """Place orders on the given strategy."""
-        raise NotImplementedError
-
-
-class ImmediateExecutionModel(ExecutionModel):
-    """Immediately send market orders using ``order_target_percent``."""
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        for data in strategy.datas:
-            target = weights.get(data._name, 0.0)
-            strategy.order_target_percent(data=data, target=target)
-
-
-class StandardDeviationExecutionModel(ExecutionModel):
-    """Only trade when recent volatility exceeds a threshold."""
-
-    def __init__(self, lookback: int = 20, threshold: float = 0.01):
-        self.lookback = lookback
-        self.threshold = threshold
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        prices = strategy.prices
-        for data in strategy.datas:
-            symbol = data._name
-            series = prices[symbol]["close"] if (symbol, "close") in prices.columns else prices[symbol]
-            if len(series) < self.lookback:
-                continue
-            vol = series.pct_change().rolling(self.lookback).std().iloc[-1]
-            if vol is not None and vol > self.threshold:
-                target = weights.get(symbol, 0.0)
-                strategy.order_target_percent(data=data, target=target)
-
-
-class VolumeWeightedAveragePriceExecutionModel(ExecutionModel):
-    """Split orders evenly over a number of steps to approximate VWAP."""
-
-    def __init__(self, steps: int = 3):
-        self.steps = steps
-        self._progress: Dict[str, int] = {}
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        for data in strategy.datas:
-            symbol = data._name
-            step = self._progress.get(symbol, 0)
-            if step >= self.steps:
-                continue
-            target = weights.get(symbol, 0.0) * (step + 1) / self.steps
-            strategy.order_target_percent(data=data, target=target)
-            self._progress[symbol] = step + 1
-
-
-class VolumePercentageExecutionModel(ExecutionModel):
-    """Execute only a percentage of the target each call."""
-
-    def __init__(self, percentage: float = 0.25):
-        self.percentage = percentage
-        self._filled: Dict[str, float] = {}
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        for data in strategy.datas:
-            symbol = data._name
-            current = self._filled.get(symbol, 0.0)
-            target = weights.get(symbol, 0.0)
-            remaining = target - current
-            if abs(remaining) < 1e-6:
-                continue
-            step_target = current + remaining * self.percentage
-            self._filled[symbol] = step_target
-            strategy.order_target_percent(data=data, target=step_target)
-
-
-class TimeProfileExecutionModel(ExecutionModel):
-    """Execute orders based on a predefined time profile (e.g. TWAP)."""
-
-    def __init__(self, profile: Dict[int, float] | None = None):
-        self.profile = profile or {0: 1.0}
-        self._called = 0
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        factor = self.profile.get(self._called, 0.0)
-        for data in strategy.datas:
-            target = weights.get(data._name, 0.0) * factor
-            strategy.order_target_percent(data=data, target=target)
-        self._called += 1
-
-
-class TrailingLimitExecutionModel(ExecutionModel):
-    """Use trailing limit orders for execution."""
-
-    def __init__(self, trail: float = 0.01):
-        self.trail = trail
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        prices = strategy.prices
-        for data in strategy.datas:
-            symbol = data._name
-            price = prices[symbol]["close"].iloc[-1] if (symbol, "close") in prices.columns else prices[symbol].iloc[-1]
-            target = weights.get(symbol, 0.0)
-            if target > 0:
-                strategy.buy(data=data, exectype=bt.Order.Limit, price=price * (1 - self.trail))
-            elif target < 0:
-                strategy.sell(data=data, exectype=bt.Order.Limit, price=price * (1 + self.trail))
-
-
-class AdaptiveExecutionModel(ExecutionModel):
-    """Switch between immediate and VWAP execution based on volatility."""
-
-    def __init__(self, threshold: float = 0.02, steps: int = 3):
-        self.threshold = threshold
-        self.vwap = VolumeWeightedAveragePriceExecutionModel(steps=steps)
-        self.immediate = ImmediateExecutionModel()
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        prices = strategy.prices
-        for data in strategy.datas:
-            symbol = data._name
-            series = prices[symbol]["close"] if (symbol, "close") in prices.columns else prices[symbol]
-            if len(series) < 2:
-                continue
-            vol = series.pct_change().iloc[-1]
-            if abs(vol) > self.threshold:
-                self.immediate.execute(strategy, {symbol: weights.get(symbol, 0.0)})
-            else:
-                self.vwap.execute(strategy, {symbol: weights.get(symbol, 0.0)})
-
-
-class BufferedExecutionModel(ExecutionModel):
-    """Only execute when target differs sufficiently from last order."""
-
-    def __init__(self, buffer: float = 0.05):
-        self.buffer = buffer
-        self._last: Dict[str, float] = {}
-
-    def execute(self, strategy: bt.Strategy, weights: Dict[str, float]):
-        for data in strategy.datas:
-            symbol = data._name
-            target = weights.get(symbol, 0.0)
-            last = self._last.get(symbol)
-            if last is None or abs(target - last) > self.buffer:
-                strategy.order_target_percent(data=data, target=target)
-                self._last[symbol] = target

pwb_toolbox-0.1.8/pwb_toolbox/backtest/insight.py

@@ -1,21 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum, auto
-from datetime import datetime
-
-
-class Direction(Enum):
-    """Possible directions for an Insight."""
-
-    UP = auto()
-    DOWN = auto()
-    FLAT = auto()
-
-
-@dataclass
-class Insight:
-    """Simple trading signal produced by an Alpha model."""
-
-    symbol: str
-    direction: Direction
-    timestamp: datetime
-    weight: float = 1.0

pwb_toolbox-0.1.8/pwb_toolbox/backtest/portfolio_models/__init__.py

@@ -1,290 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Dict, Iterable
-import numpy as np
-import pandas as pd
-
-from .. import Insight, Direction
-
-
-class PortfolioConstructionModel(ABC):
-    """Abstract base class for portfolio construction models."""
-
-    @abstractmethod
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        """Return target weights for each symbol."""
-        pass
-
-
-class EqualWeightingPortfolioConstructionModel(PortfolioConstructionModel):
-    """Allocate equal weight to all non-flat insights."""
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active:
-            return {}
-        w = 1.0 / len(active)
-        return {i.symbol: (w if i.direction == Direction.UP else -w) for i in active}
-
-
-class InsightWeightingPortfolioConstructionModel(PortfolioConstructionModel):
-    """Weight positions according to insight weight attribute."""
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active:
-            return {}
-        total = sum(abs(i.weight) for i in active)
-        if total == 0:
-            return {}
-        return {
-            i.symbol: (i.weight / total) * (1 if i.direction == Direction.UP else -1)
-            for i in active
-        }
-
-
-class RiskParityPortfolioConstructionModel(PortfolioConstructionModel):
-    """Simple risk parity based on inverse volatility."""
-
-    def __init__(self, lookback: int = 20):
-        self.lookback = lookback
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active or price_data is None:
-            return {}
-        vols = {}
-        for ins in active:
-            prices = (
-                price_data[ins.symbol]["close"]
-                if (ins.symbol, "close") in price_data.columns
-                else price_data[ins.symbol]
-            )
-            if len(prices) < self.lookback:
-                return {}
-            vols[ins.symbol] = prices.pct_change().rolling(self.lookback).std().iloc[-1]
-        inv_vol = {s: 1.0 / v for s, v in vols.items() if v > 0}
-        total = sum(inv_vol.values())
-        if total == 0:
-            return {}
-        return {
-            s: (inv_vol[s] / total)
-            * (
-                1
-                if next(i for i in active if i.symbol == s).direction == Direction.UP
-                else -1
-            )
-            for s in inv_vol
-        }
-
-
-class MeanVarianceOptimizationPortfolioConstructionModel(PortfolioConstructionModel):
-    """Mean-variance optimization with weight normalization."""
-
-    def __init__(self, lookback: int = 60):
-        self.lookback = lookback
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active or price_data is None:
-            return {}
-        symbols = [i.symbol for i in active]
-        df = price_data[symbols]
-        if isinstance(df.columns, pd.MultiIndex):
-            df = df.xs("close", axis=1, level=-1)
-        if len(df) < self.lookback:
-            return {}
-        rets = df.pct_change().dropna()
-        mu = rets.mean()
-        cov = rets.cov()
-        inv_cov = np.linalg.pinv(cov.values)
-        exp = np.array(
-            [
-                mu[s]
-                * (
-                    1
-                    if next(i for i in active if i.symbol == s).direction
-                    == Direction.UP
-                    else -1
-                )
-                for s in mu.index
-            ]
-        )
-        raw = inv_cov.dot(exp)
-        total = np.sum(np.abs(raw))
-        if total == 0:
-            return {}
-        w = raw / total
-        return {s: float(w[i]) for i, s in enumerate(mu.index)}
-
-
-class UnconstrainedMeanVariancePortfolioConstructionModel(PortfolioConstructionModel):
-    """Mean-variance optimization without normalization of weights."""
-
-    def __init__(self, lookback: int = 60):
-        self.lookback = lookback
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active or price_data is None:
-            return {}
-        symbols = [i.symbol for i in active]
-        df = price_data[symbols]
-        if isinstance(df.columns, pd.MultiIndex):
-            df = df.xs("close", axis=1, level=-1)
-        if len(df) < self.lookback:
-            return {}
-        rets = df.pct_change().dropna()
-        mu = rets.mean()
-        cov = rets.cov()
-        inv_cov = np.linalg.pinv(cov.values)
-        exp = np.array(
-            [
-                mu[s]
-                * (
-                    1
-                    if next(i for i in active if i.symbol == s).direction
-                    == Direction.UP
-                    else -1
-                )
-                for s in mu.index
-            ]
-        )
-        raw = inv_cov.dot(exp)
-        return {s: float(raw[i]) for i, s in enumerate(mu.index)}
-
-
-class BlackLittermanOptimizationPortfolioConstructionModel(
-    MeanVarianceOptimizationPortfolioConstructionModel
-):
-    """Simplified Black-Litterman model using a blend of market and view returns."""
-
-    def __init__(self, lookback: int = 60, view_weight: float = 0.5):
-        super().__init__(lookback)
-        self.view_weight = view_weight
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active or price_data is None:
-            return {}
-        symbols = [i.symbol for i in active]
-        df = price_data[symbols]
-        if isinstance(df.columns, pd.MultiIndex):
-            df = df.xs("close", axis=1, level=-1)
-        if len(df) < self.lookback:
-            return {}
-        rets = df.pct_change().dropna()
-        market_mu = rets.mean()
-        view_mu = pd.Series(
-            {i.symbol: (1 if i.direction == Direction.UP else -1) for i in active}
-        )
-        mu = (1 - self.view_weight) * market_mu + self.view_weight * view_mu
-        cov = rets.cov()
-        inv_cov = np.linalg.pinv(cov.values)
-        exp = mu.loc[market_mu.index].values
-        raw = inv_cov.dot(exp)
-        total = np.sum(np.abs(raw))
-        if total == 0:
-            return {}
-        w = raw / total
-        return {s: float(w[i]) for i, s in enumerate(market_mu.index)}
-
-
-class TargetPercentagePortfolioConstructionModel(PortfolioConstructionModel):
-    """Return predefined target portfolio percentages."""
-
-    def __init__(self, targets: Dict[str, float]):
-        self.targets = targets
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active_symbols = {
-            i.symbol: i for i in insights if i.direction != Direction.FLAT
-        }
-        return {
-            s: (
-                self.targets.get(s, 0.0)
-                * (1 if active_symbols[s].direction == Direction.UP else -1)
-            )
-            for s in active_symbols
-            if s in self.targets
-        }
-
-
-class DollarCostAveragingPortfolioConstructionModel(PortfolioConstructionModel):
-    """Allocate a fixed percentage to each new insight."""
-
-    def __init__(self, allocation: float = 0.1):
-        self.allocation = allocation
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        active = [i for i in insights if i.direction != Direction.FLAT]
-        if not active:
-            return {}
-        return {
-            i.symbol: self.allocation * (1 if i.direction == Direction.UP else -1)
-            for i in active
-        }
-
-
-class InsightRatioPortfolioConstructionModel(PortfolioConstructionModel):
-    """Scale long and short exposure by the ratio of insights."""
-
-    def weights(
-        self,
-        insights: Iterable[Insight],
-        price_data: pd.DataFrame | None = None,
-    ) -> Dict[str, float]:
-        ups = [i for i in insights if i.direction == Direction.UP]
-        downs = [i for i in insights if i.direction == Direction.DOWN]
-        total = len(ups) + len(downs)
-        if total == 0:
-            return {}
-        up_share = len(ups) / total
-        down_share = len(downs) / total
-        weights = {}
-        if ups:
-            per = up_share / len(ups)
-            for i in ups:
-                weights[i.symbol] = per
-        if downs:
-            per = down_share / len(downs)
-            for i in downs:
-                weights[i.symbol] = -per
-        return weights

pwb_toolbox-0.1.8/pwb_toolbox/backtest/risk_models/__init__.py

@@ -1,175 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Iterable
-
-
-class RiskManagementModel:
-    """Base class for risk management models."""
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float]) -> Dict[str, float]:
-        """Return adjusted target weights based on risk rules."""
-        raise NotImplementedError
-
-
-class TrailingStopRiskManagementModel(RiskManagementModel):
-    """Close positions if price falls a percentage from the peak."""
-
-    def __init__(self, percent: float = 0.1):
-        self.percent = percent
-        self._highs: Dict[str, float] = {}
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float]) -> Dict[str, float]:
-        out = dict(weights)
-        for symbol, weight in weights.items():
-            price = prices.get(symbol)
-            if price is None:
-                continue
-            high = self._highs.get(symbol, price)
-            if price > high:
-                high = price
-            self._highs[symbol] = high
-            if weight != 0 and price <= high * (1 - self.percent):
-                out[symbol] = 0.0
-        return out
-
-
-class MaximumDrawdownPercentPerSecurity(TrailingStopRiskManagementModel):
-    """Alias of trailing stop for per-security drawdown."""
-
-    def __init__(self, max_drawdown: float = 0.1):
-        super().__init__(percent=max_drawdown)
-
-
-class MaximumDrawdownPercentPortfolio(RiskManagementModel):
-    """Flatten portfolio if total drawdown exceeds a threshold."""
-
-    def __init__(self, max_drawdown: float = 0.2):
-        self.max_drawdown = max_drawdown
-        self._high: float | None = None
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float]) -> Dict[str, float]:
-        nav = sum(weights.get(s, 0.0) * prices.get(s, 0.0) for s in weights)
-        if self._high is None:
-            self._high = nav
-        if nav > self._high:
-            self._high = nav
-        if self._high and nav <= self._high * (1 - self.max_drawdown):
-            return {s: 0.0 for s in weights}
-        return weights
-
-
-class MaximumUnrealizedProfitPercentPerSecurity(RiskManagementModel):
-    """Take profit once unrealized gain exceeds threshold."""
-
-    def __init__(self, max_profit: float = 0.2):
-        self.max_profit = max_profit
-        self._entry: Dict[str, float] = {}
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float]) -> Dict[str, float]:
-        out = dict(weights)
-        for symbol, weight in weights.items():
-            price = prices.get(symbol)
-            if price is None:
-                continue
-            if weight == 0:
-                self._entry.pop(symbol, None)
-                continue
-            entry = self._entry.get(symbol)
-            if entry is None:
-                self._entry[symbol] = price
-                continue
-            if weight > 0:
-                profit = (price - entry) / entry
-            else:
-                profit = (entry - price) / entry
-            if profit >= self.max_profit:
-                out[symbol] = 0.0
-                self._entry.pop(symbol, None)
-        return out
-
-
-class MaximumTotalPortfolioExposure(RiskManagementModel):
-    """Scale weights so total gross exposure stays below a limit."""
-
-    def __init__(self, max_exposure: float = 1.0):
-        self.max_exposure = max_exposure
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float] | None = None) -> Dict[str, float]:
-        gross = sum(abs(w) for w in weights.values())
-        if gross <= self.max_exposure or gross == 0:
-            return weights
-        scale = self.max_exposure / gross
-        return {s: w * scale for s, w in weights.items()}
-
-
-class SectorExposureRiskManagementModel(RiskManagementModel):
-    """Limit exposure by sector."""
-
-    def __init__(self, sector_map: Dict[str, str], limit: float = 0.3):
-        self.sector_map = sector_map
-        self.limit = limit
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float] | None = None) -> Dict[str, float]:
-        out = dict(weights)
-        exposures: Dict[str, float] = {}
-        for symbol, weight in weights.items():
-            sector = self.sector_map.get(symbol)
-            if sector is None:
-                continue
-            exposures[sector] = exposures.get(sector, 0.0) + abs(weight)
-        for sector, exposure in exposures.items():
-            if exposure > self.limit and exposure != 0:
-                factor = self.limit / exposure
-                for symbol, weight in weights.items():
-                    if self.sector_map.get(symbol) == sector:
-                        out[symbol] = weight * factor
-        return out
-
-
-class MaximumOrderQuantityPercentPerSecurity(RiskManagementModel):
-    """Cap the change in weight for each security per evaluation call."""
-
-    def __init__(self, max_percent: float = 0.1):
-        self.max_percent = max_percent
-        self._prev: Dict[str, float] = {}
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float] | None = None) -> Dict[str, float]:
-        out = {}
-        for symbol, target in weights.items():
-            prev = self._prev.get(symbol, 0.0)
-            diff = target - prev
-            if diff > self.max_percent:
-                new = prev + self.max_percent
-            elif diff < -self.max_percent:
-                new = prev - self.max_percent
-            else:
-                new = target
-            out[symbol] = new
-            self._prev[symbol] = new
-        return out
-
-
-class CompositeRiskManagementModel(RiskManagementModel):
-    """Combine multiple risk models sequentially."""
-
-    def __init__(self, models: Iterable[RiskManagementModel]):
-        self.models = list(models)
-
-    def evaluate(self, weights: Dict[str, float], prices: Dict[str, float]) -> Dict[str, float]:
-        out = dict(weights)
-        for model in self.models:
-            out = model.evaluate(out, prices)
-        return out
-
-
-__all__ = [
-    "RiskManagementModel",
-    "TrailingStopRiskManagementModel",
-    "MaximumDrawdownPercentPerSecurity",
-    "MaximumDrawdownPercentPortfolio",
-    "MaximumUnrealizedProfitPercentPerSecurity",
-    "MaximumTotalPortfolioExposure",
-    "SectorExposureRiskManagementModel",
-    "MaximumOrderQuantityPercentPerSecurity",
-    "CompositeRiskManagementModel",
-]

pwb_toolbox-0.1.8/pwb_toolbox/backtest/universe_models/__init__.py

@@ -1,183 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from datetime import date
-from typing import Callable, Dict, Iterable, List, Sequence
-
-import pandas as pd
-
-from ...datasets import load_dataset
-
-
-class UniverseSelectionModel(ABC):
-    """Base class for universe selection models."""
-
-    @abstractmethod
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        """Return the active list of symbols."""
-        raise NotImplementedError
-
-
-class ManualUniverseSelectionModel(UniverseSelectionModel):
-    """Universe defined by a static list of tickers."""
-
-    def __init__(self, symbols: Sequence[str]):
-        self._symbols = list(symbols)
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        return list(self._symbols)
-
-
-class ScheduledUniverseSelectionModel(UniverseSelectionModel):
-    """Switch universe based on a schedule of dates."""
-
-    def __init__(self, schedule: Dict[date | str, Sequence[str]]):
-        self.schedule = {
-            (pd.Timestamp(k).date() if not isinstance(k, date) else k): list(v)
-            for k, v in schedule.items()
-        }
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        if not self.schedule:
-            return []
-        dt = pd.Timestamp(as_of or date.today()).date()
-        valid = [d for d in self.schedule if d <= dt]
-        if not valid:
-            return []
-        last = max(valid)
-        return self.schedule[last]
-
-
-class CoarseFundamentalUniverseSelectionModel(UniverseSelectionModel):
-    """Universe filtered using coarse fundamental data."""
-
-    def __init__(
-        self,
-        selector: Callable[[pd.DataFrame], Iterable[str]],
-        dataset: str = "Stocks-Quarterly-BalanceSheet",
-    ):
-        self.selector = selector
-        self.dataset = dataset
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        df = load_dataset(self.dataset)
-        return list(self.selector(df))
-
-
-class FineFundamentalUniverseSelectionModel(UniverseSelectionModel):
-    """Universe filtered using fine fundamental data."""
-
-    def __init__(
-        self,
-        selector: Callable[[pd.DataFrame], Iterable[str]],
-        dataset: str = "Stocks-Quarterly-Earnings",
-    ):
-        self.selector = selector
-        self.dataset = dataset
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        df = load_dataset(self.dataset)
-        return list(self.selector(df))
-
-
-class ETFConstituentsUniverseSelectionModel(UniverseSelectionModel):
-    """Universe containing constituents of a given ETF."""
-
-    def __init__(self, etf: str):
-        self.etf = etf
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        df = load_dataset("ETF-Constituents")
-        if "etf" in df.columns:
-            col = "etf"
-        else:
-            col = df.columns[0] if df.columns else "etf"
-        if df.empty:
-            return []
-        return list(df[df[col] == self.etf]["symbol"].unique())
-
-
-class IndexConstituentsUniverseSelectionModel(UniverseSelectionModel):
-    """Universe of constituents for a specified index."""
-
-    def __init__(self, index: str):
-        self.index = index
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        df = load_dataset("Index-Constituents")
-        if df.empty:
-            return []
-        col = "index" if "index" in df.columns else df.columns[0]
-        return list(df[df[col] == self.index]["symbol"].unique())
-
-
-class OptionUniverseSelectionModel(UniverseSelectionModel):
-    """Universe consisting of options for the given underlyings."""
-
-    def __init__(self, underlying_symbols: Sequence[str]):
-        self.underlyings = list(underlying_symbols)
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        return list(self.underlyings)
-
-
-class ADRUniverseSelectionModel(UniverseSelectionModel):
-    """Universe of American Depositary Receipts."""
-
-    def __init__(self, dataset: str = "ADR-Listings"):
-        self.dataset = dataset
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        df = load_dataset(self.dataset)
-        if df.empty:
-            return []
-        return list(df["symbol"].unique())
-
-
-class CryptoUniverseSelectionModel(UniverseSelectionModel):
-    """Universe built from cryptocurrency tickers."""
-
-    def __init__(self, top_n: int | None = None):
-        self.top_n = top_n
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        df = load_dataset("Cryptocurrencies-Daily-Price")
-        syms = list(dict.fromkeys(df["symbol"]))
-        if self.top_n is not None:
-            syms = syms[: self.top_n]
-        return syms
-
-
-class UniverseSelectionModelChain(UniverseSelectionModel):
-    """Combine multiple universe selection models."""
-
-    def __init__(self, models: Iterable[UniverseSelectionModel]):
-        self.models = list(models)
-
-    def symbols(self, as_of: date | str | None = None) -> List[str]:
-        all_syms: List[str] = []
-        for m in self.models:
-            all_syms.extend(m.symbols(as_of))
-        seen = set()
-        uniq = []
-        for s in all_syms:
-            if s not in seen:
-                seen.add(s)
-                uniq.append(s)
-        return uniq
-
-
-__all__ = [
-    "UniverseSelectionModel",
-    "ManualUniverseSelectionModel",
-    "ScheduledUniverseSelectionModel",
-    "CoarseFundamentalUniverseSelectionModel",
-    "FineFundamentalUniverseSelectionModel",
-    "ETFConstituentsUniverseSelectionModel",
-    "IndexConstituentsUniverseSelectionModel",
-    "OptionUniverseSelectionModel",
-    "ADRUniverseSelectionModel",
-    "CryptoUniverseSelectionModel",
-    "UniverseSelectionModelChain",
-]
-