openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/__init__.py

@@ -0,0 +1,85 @@
+"""OpenBacktesting native historical backtesting kernel."""
+
+import sys as _sys
+
+__version__ = "0.2.0"
+
+from . import colors, indicators, inputs, lib, runtime  # noqa: F401
+from .colors import Color as Color
+from .data.context import DataContext as DataContext
+from .data.timeframe import Timeframe as Timeframe
+from .data.timeframe import TimeframeUnit as TimeframeUnit
+from .engine import Backtest as Backtest
+from .engine import Strategy as Strategy
+from .logs import RunLogs as RunLogs
+from .simulation.config import CommissionType as CommissionType
+from .simulation.config import DefaultOrderSize as DefaultOrderSize
+from .simulation.config import EndPolicy as EndPolicy
+from .simulation.config import ExecutionTiming as ExecutionTiming
+from .simulation.config import QuantityType as QuantityType
+from .simulation.config import SlippageType as SlippageType
+from .strategy.bar_state import BarState as BarState
+from .strategy.declaration import backtest as backtest
+from .util import try_
+
+# Skip Pool in pdoc3 API docs. Interested users get the warning.
+__pdoc__ = {"openbacktesting.Pool": False}
+
+
+# Add overridable openbacktesting.Pool used for parallel optimization
+def Pool(processes=None, initializer=None, initargs=()):
+    """Create an optimization execution pool; spawn uses a thread pool by default. Advanced callers may override this entry point; multiprocessing calls require a main guard."""
+    import multiprocessing as mp
+    import sys
+
+    # Revert performance related change in Python>=3.14
+    if sys.platform.startswith("linux") and mp.get_start_method(allow_none=True) != "fork":
+        try_(lambda: mp.set_start_method("fork"))
+    if mp.get_start_method() == "spawn":
+        import warnings
+
+        warnings.warn(
+            "If you want to use multi-process optimization with "
+            "`multiprocessing.get_start_method() == 'spawn'` (e.g. on Windows),"
+            "set `openbacktesting.Pool = multiprocessing.Pool` (or of the desired context) "
+            "and hide `bt.optimize()` call behind a `if __name__ == '__main__'` guard. "
+            "Currently using thread-based paralellism, "
+            "which might be slightly slower for non-numpy / non-GIL-releasing code. "
+            "See README.md",
+            category=RuntimeWarning,
+            stacklevel=3,
+        )
+        from multiprocessing.dummy import Pool
+
+        return Pool(processes, initializer, initargs)
+    else:
+        return mp.Pool(processes, initializer, initargs)
+
+
+from . import (  # noqa: F401
+    aggregation,
+    broker,
+    data,
+    helpers,
+    optimization,
+    parallel,
+    simulation,
+    strategy,
+    util,
+)
+
+# The old module path and new file share the same objects, preserving imports, patching, and pickle lookup.
+for _module_name in (
+    "aggregation",
+    "broker",
+    "data",
+    "helpers",
+    "optimization",
+    "parallel",
+    "strategy",
+    "util",
+):
+    _module = _sys.modules[f"{__name__}.{_module_name}"]
+    globals()[f"_{_module_name}"] = _module
+    _sys.modules[f"{__name__}._{_module_name}"] = _module
+del _module_name, _module

openbacktesting/aggregation.py

@@ -0,0 +1,8 @@
+"""Compatibility exports for the old aggregation path; implemented in data.aggregation."""
+
+from openbacktesting.data.aggregation import (
+    OHLCV_AGG,
+    TRADES_AGG,
+)
+
+__all__ = ["OHLCV_AGG", "TRADES_AGG"]

openbacktesting/broker/__init__.py

@@ -0,0 +1,54 @@
+"""Compatibility exports for the old broker path; implemented in broker.core."""
+
+from openbacktesting.broker.core import (
+    Order as Order,
+)
+from openbacktesting.broker.core import (
+    Position as Position,
+)
+from openbacktesting.broker.core import (
+    Trade as Trade,
+)
+from openbacktesting.broker.core import (
+    __pdoc__ as __pdoc__,
+)
+from openbacktesting.broker.core import (
+    _Broker as _Broker,
+)
+from openbacktesting.broker.core import (
+    _OutOfMoneyError as _OutOfMoneyError,
+)
+
+from .commission import Commission as Commission
+from .core import OrderGroup as OrderGroup
+from .execution import Slippage as Slippage
+from .instrument import InstrumentSpec as InstrumentSpec
+from .models import (
+    AccountSnapshot as AccountSnapshot,
+)
+from .models import ClosedTradeStats as ClosedTradeStats
+from .models import (
+    Fill as Fill,
+)
+from .models import (
+    OrderEvent as OrderEvent,
+)
+from .models import (
+    OrderSizingSnapshot as OrderSizingSnapshot,
+)
+from .models import (
+    OrderSnapshot as OrderSnapshot,
+)
+from .models import (
+    OrderStatus as OrderStatus,
+)
+from .models import (
+    PositionSnapshot as PositionSnapshot,
+)
+from .models import (
+    RunSummary as RunSummary,
+)
+from .models import (
+    TradeAllocation as TradeAllocation,
+)
+from .requests import OrderRequest as OrderRequest

openbacktesting/broker/commission.py

@@ -0,0 +1,57 @@
+"""Reconstructible linear fee values without account or strategy state."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from openbacktesting.broker.models import finite
+
+
+@dataclass(frozen=True)
+class Commission:
+    """Fixed fee per fill, notional rate, and fee per asset unit; a rate of 0.002 means 0.2%."""
+
+    fixed: float = 0.0
+    relative: float = 0.0
+    per_unit: float = 0.0
+
+    def __post_init__(self):
+        for name in ("fixed", "relative", "per_unit"):
+            object.__setattr__(self, name, finite(getattr(self, name), f"commission_{name}"))
+        if self.fixed < 0 or self.per_unit < 0 or not -0.1 <= self.relative < 0.1:
+            raise ValueError("Commission configuration is outside the allowed range")
+
+    def calculate(self, qty: float, price: float) -> float:
+        """Calculate fees from actual fill quantity and price; the caller validates fill values."""
+        return self.fixed + abs(qty) * price * self.relative + abs(qty) * self.per_unit
+
+    def snapshot(self) -> dict:
+        """Export independent plain values with a model version."""
+        return {
+            "kind": "linear",
+            "version": 1,
+            "fixed": self.fixed,
+            "relative": self.relative,
+            "per_unit": self.per_unit,
+        }
+
+    @classmethod
+    def from_snapshot(cls, value: Mapping) -> "Commission":
+        """Restore a complete snapshot strictly; reject unknown versions, fields, and implicit defaults."""
+        if not isinstance(value, Mapping):
+            raise TypeError("Commission snapshot must be a mapping")
+        if set(value) != {"kind", "version", "fixed", "relative", "per_unit"}:
+            raise ValueError("Commission snapshot has missing or unknown fields")
+        if value["kind"] != "linear" or type(value["version"]) is not int or value["version"] != 1:
+            raise ValueError("Unsupported Commission snapshot model or version")
+        return cls(value["fixed"], value["relative"], value["per_unit"])
+
+
+def normalize_commission(value: float | tuple[float, float] | Commission) -> Commission:
+    """Normalize legacy fee inputs to a plain-value model; callables are not accepted."""
+    if isinstance(value, Commission):
+        return value
+    if isinstance(value, tuple):
+        if len(value) != 2:
+            raise ValueError("commission tuple must contain a fixed fee and a rate")
+        return Commission(fixed=value[0], relative=value[1])
+    return Commission(relative=value)