"Vibe-Trading: Your Personal Trading Agent"
Python ai-agentalgorithmic-tradingbacktestingfintechllmmcpmulti-agentpythonquantitative-financetrading
Add allow_nonpositive_prices: open on negative-price bars, still reject zero (#816)
ALI EMADIdffa8fe03fe0
diff --git a/agent/backtest/engines/base.py b/agent/backtest/engines/base.pyindex 512e4e98a..0b66f1900 100644--- a/agent/backtest/engines/base.py+++ b/agent/backtest/engines/base.py@@ -360,6 +360,14 @@ class BaseEngine(ABC):self.config = configself.initial_capital: float = config.get("initial_cash", 1_000_000)self.default_leverage: float = config.get("leverage", 1.0)+ # Markets that clear at or below zero (e.g. EU day-ahead power) opt in+ # to opening on negative-price bars. Default False preserves the legacy+ # "reject any open_price <= 0" behavior. An exactly-zero open is always+ # rejected (undefined size = notional / price); negatives are handled by+ # abs()-based sizing and margin below.+ self.allow_nonpositive_prices: bool = bool(+ config.get("allow_nonpositive_prices", False)+ )self.capital: float = self.initial_capitalself.positions: Dict[str, Position] = {}self.trades: List[TradeRecord] = []@@ -439,14 +447,24 @@ class BaseEngine(ABC):def _calc_margin(self, symbol: str, size: float, price: float, leverage: float,) -> float:- """Margin (collateral) required for a position."""- return size * price / leverage+ """Margin (collateral) required for a position.++ ``abs(price)`` so collateral stays positive when the entry price is+ negative; for the usual positive price this is unchanged.+ """+ return size * abs(price) / leveragedef _calc_raw_size(self, symbol: str, target_notional: float, price: float,) -> float:- """Convert target notional exposure to number of units/contracts."""- return target_notional / price+ """Convert target notional exposure to number of units/contracts.++ Size is a positive magnitude — direction carries the sign elsewhere —+ so divide by ``abs(price)``; a negative entry price must not flip the+ size negative (which the ``size <= 0`` guard would then reject). For a+ positive price this is unchanged.+ """+ return target_notional / abs(price)def _leverage_for_symbol(self, symbol: str) -> float:"""Return leverage used to size and margin one symbol."""@@ -949,7 +967,10 @@ class BaseEngine(ABC):if not self.can_execute(symbol, direction, bar):return Noneopen_price = float(bar.get("open", bar.get("close", 0)))- if open_price <= 0:+ # Zero is always rejected (size = notional / price is undefined);+ # negatives are rejected unless this engine opted into non-positive+ # prices, in which case abs()-based sizing/margin below handle them.+ if open_price == 0 or (open_price < 0 and not self.allow_nonpositive_prices):return Noneprice = self.apply_slippage(open_price, direction)leverage = self._leverage_for_symbol(symbol)diff --git a/agent/backtest/loaders/base.py b/agent/backtest/loaders/base.pyindex a4bef00a8..dc74ef5a9 100644--- a/agent/backtest/loaders/base.py+++ b/agent/backtest/loaders/base.py@@ -47,7 +47,12 @@ def validate_date_range(start_date: str, end_date: str) -> None:raise ValueError(f"start_date ({start_date}) > end_date ({end_date})")-def validate_ohlc(frame: pd.DataFrame, *, strategy: str = "drop") -> pd.DataFrame:+def validate_ohlc(+ frame: pd.DataFrame,+ *,+ strategy: str = "drop",+ allow_nonpositive_prices: bool = False,+) -> pd.DataFrame:"""Drop, flag, or reject bars that violate OHLC invariants.Loaders only drop NaN rows, so structurally dirty bars — ``high < low``,@@ -57,11 +62,24 @@ def validate_ohlc(frame: pd.DataFrame, *, strategy: str = "drop") -> pd.DataFramcanonical loader-boundary check; call it after the existing ``dropna`` so asingle sanity pass guards every source.+ Structural invariants (``high < low`` and high/low failing to bracket+ open/close) are always enforced. The *positivity* invariant is+ configurable: some markets clear at or below zero legitimately (European+ day-ahead power routinely prints negative), and a rolling statistic over a+ silently gap-filled series is worse than a well-defined negative bar. When+ ``allow_nonpositive_prices`` is set, negative prices pass through and only+ an exactly-zero price is rejected — zero is genuinely undefined for+ notional sizing (``size = notional / price``) and margin, whereas a+ negative price is handled by ``abs()``-based sizing in the engine.+Args:frame: OHLCV frame with at least ``open``/``high``/``low``/``close``columns. NaN handling is left to the caller's ``dropna``.strategy: ``"drop"`` (remove offending rows, default), ``"warn"``(log and keep), or ``"raise"`` (raise on any violation).+ allow_nonpositive_prices: when ``True``, keep bars with negative+ prices and reject only exact zeros; when ``False`` (default,+ unchanged behavior) reject any price ``<= 0``.Returns:The frame with invalid rows removed (``"drop"``) or unchanged@@ -76,17 +94,18 @@ def validate_ohlc(frame: pd.DataFrame, *, strategy: str = "drop") -> pd.DataFramreturn frameopen_, high, low, close = (frame[c] for c in required)- invalid = (+ structural = ((high < low)| (high < open_)| (high < close)| (low > open_)| (low > close)- | (open_ <= 0)- | (high <= 0)- | (low <= 0)- | (close <= 0))+ if allow_nonpositive_prices:+ nonpositive = (open_ == 0) | (high == 0) | (low == 0) | (close == 0)+ else:+ nonpositive = (open_ <= 0) | (high <= 0) | (low <= 0) | (close <= 0)+ invalid = structural | nonpositiven_invalid = int(invalid.sum())if n_invalid == 0:return framediff --git a/agent/tests/fixtures/negative_close_bars.csv b/agent/tests/fixtures/negative_close_bars.csvnew file mode 100644index 000000000..c4ade1fc1--- /dev/null+++ b/agent/tests/fixtures/negative_close_bars.csv@@ -0,0 +1,14 @@+# Real EU day-ahead power bars that clear at or below zero.+# Source: ENTSO-E day-ahead prices via Energy-Charts (Fraunhofer ISE),+# Bundesnetzagentur | SMARD.de. Licensed CC BY 4.0.+# Window 2025-07-20..2025-12-31. These are the daily bars whose *close* is+# non-positive: four strictly negative (kept when allow_nonpositive_prices)+# and one exactly zero (POWER-DA-DELU 2025-10-26, always rejected). Two also+# open negative (POWER-DA-DELU 2025-10-04). Hourly-derived daily low goes far+# below zero on solar-heavy DELU days.+code,trade_date,open,high,low,close,volume+POWER-DA-NO2,2025-10-04,11.22,12.64,-0.09,-0.09,0.0+POWER-DA-DELU,2025-09-15,1.39,54.31,-14.27,-0.09,0.0+POWER-DA-DELU,2025-10-03,82.76,128.62,-0.08,-0.02,0.0+POWER-DA-DELU,2025-10-04,-0.01,4.02,-5.02,-1.03,0.0+POWER-DA-DELU,2025-10-26,3.99,49.34,-1.05,0.00,0.0diff --git a/agent/tests/test_nonpositive_prices.py b/agent/tests/test_nonpositive_prices.pynew file mode 100644index 000000000..85c8ea012--- /dev/null+++ b/agent/tests/test_nonpositive_prices.py@@ -0,0 +1,192 @@+"""allow_nonpositive_prices: open on negative-price bars, still reject zero.++Markets like European day-ahead power clear negative routinely. The default+(flag off) still drops/rejects any non-positive price, so nothing changes for+existing markets; when the flag is on, negative prices flow through and only an+exactly-zero price is rejected (size = notional / price and margin are+undefined at zero, but well-defined for negatives via abs()).++Fixture `fixtures/negative_close_bars.csv` holds the five real bars from a+2025 NO2/DE-LU window whose close is non-positive (four negative, one exactly+zero). Source: ENTSO-E via Energy-Charts (Fraunhofer ISE),+Bundesnetzagentur | SMARD.de, CC BY 4.0.+"""++from __future__ import annotations++from pathlib import Path++import numpy as np+import pandas as pd+import pytest++from backtest.engines.base import BaseEngine+from backtest.loaders.base import validate_ohlc++FIXTURE = Path(__file__).parent / "fixtures" / "negative_close_bars.csv"+++def _negative_close_frame() -> pd.DataFrame:+ df = pd.read_csv(FIXTURE, comment="#")+ df.index = pd.to_datetime(df.pop("trade_date"))+ df.index.name = "trade_date"+ return df+++# ---------------------------------------------------------------------------+# loader: validate_ohlc positivity gate+# ---------------------------------------------------------------------------+++def test_default_drops_every_nonpositive_bar() -> None:+ """Unchanged behavior: with the flag off, all five non-positive-close bars+ (and their sub-zero lows) are dropped."""+ frame = _negative_close_frame()+ assert len(frame) == 5+ cleaned = validate_ohlc(frame)+ assert cleaned.empty+++def test_allow_keeps_negatives_rejects_exact_zero() -> None:+ """With the flag on, the four negative-close bars survive and only the+ exactly-zero close (DELU 2025-10-26) is dropped — structural invariants+ (high brackets low/open/close) still hold for all five real bars."""+ frame = _negative_close_frame()+ cleaned = validate_ohlc(frame, allow_nonpositive_prices=True)+ assert len(cleaned) == 4+ kept_closes = sorted(round(c, 2) for c in cleaned["close"])+ assert kept_closes == [-1.03, -0.09, -0.09, -0.02]+ assert 0.0 not in list(cleaned["close"])+++def test_why_loader_drops_exact_zero_inf_downstream() -> None:+ """Pins *why* an exact-zero close is dropped at the loader, not kept.++ Both the benchmark (``benchmark.py``) and the position simulation+ (``engines/base.py``) compute per-bar returns as+ ``close.pct_change().fillna(0.0)`` over a *raw* close series. If a ``0.00``+ clear survived into that series, the bar *after* it divides by zero and+ yields ``inf`` — and ``fillna(0.0)`` does not neutralize it (it fills NaN,+ not inf), so the benchmark's ``(1 + r).prod()`` collapses to ``nan``.++ Negatives divide cleanly (engine sizing uses ``abs(price)``), so they are+ kept; exact zero is genuinely undefined and is therefore rejected at the+ loader *and* the engine. This test encodes that contract so the asymmetry+ is not silently "fixed" by later relaxing the loader. See #571.+ """+ idx = pd.to_datetime(["2025-10-24", "2025-10-25", "2025-10-26", "2025-10-27"])++ # If the loader had KEPT the 0.00 close, the raw return series blows up.+ kept = pd.Series([42.0, -1.03, 0.00, 42.0], index=idx)+ ret_if_kept = kept.pct_change().fillna(0.0) # the exact downstream expression+ assert np.isinf(ret_if_kept.iloc[-1]) # 0.00 -> inf next bar+ with np.errstate(invalid="ignore"): # the nan-from-inf is the point, not a bug+ bench_total = float((1 + ret_if_kept).prod())+ assert not np.isfinite(bench_total) # benchmark total -> nan++ # The loader drops the exact-zero bar, so the surviving series is inf-free.+ frame = pd.DataFrame(+ {+ "open": kept,+ "high": kept.abs() + 1.0,+ "low": kept - 1.0,+ "close": kept,+ },+ index=idx,+ )+ cleaned = validate_ohlc(frame, allow_nonpositive_prices=True)+ assert 0.0 not in list(cleaned["close"]) # zero bar removed+ safe_ret = cleaned["close"].pct_change().fillna(0.0)+ assert np.isfinite(safe_ret.to_numpy()).all() # negatives stay finite+++def test_allow_still_enforces_structural_invariants() -> None:+ """The flag relaxes only positivity, never the OHLC bracket invariants."""+ frame = pd.DataFrame(+ [(-5.0, -1.0, -8.0, -12.0, 0.0)], # close -12 < low -8 -> invalid bracket+ columns=["open", "high", "low", "close", "volume"],+ index=pd.to_datetime(["2025-10-04"]),+ )+ assert validate_ohlc(frame, allow_nonpositive_prices=True).empty+++# ---------------------------------------------------------------------------+# engine: opening / sizing / margin / pnl through zero+# ---------------------------------------------------------------------------+++class _PlainEngine(BaseEngine):+ """Minimal concrete engine: identity slippage/rounding, zero commission,+ all trades allowed — isolates BaseEngine's price handling."""++ def can_execute(self, symbol: str, direction: int, bar: pd.Series) -> bool:+ return True++ def round_size(self, raw_size: float, price: float) -> float:+ return raw_size++ def calc_commission(self, size: float, price: float, direction: int, is_open: bool) -> float:+ return 0.0++ def apply_slippage(self, price: float, direction: int) -> float:+ return price+++def _engine(*, allow: bool) -> _PlainEngine:+ return _PlainEngine({"initial_cash": 1_000_000, "allow_nonpositive_prices": allow})+++def _bar_df(open_px: float, ts: str = "2025-10-04") -> tuple[pd.DataFrame, pd.Timestamp]:+ idx = pd.to_datetime([ts])+ df = pd.DataFrame(+ {"open": [open_px], "high": [max(open_px, 1.0)], "low": [open_px], "close": [open_px]},+ index=idx,+ )+ return df, idx[0]+++def test_opens_on_negative_price_bar_when_allowed() -> None:+ eng = _engine(allow=True)+ df, ts = _bar_df(-5.0) # DELU 2025-10-04 opened at -0.01; use -5 for headroom+ order = eng._plan_open_order("POWER-DA-DELU", 0.5, df, ts, equity=1_000_000)+ assert order is not None+ assert order.direction == 1+ # Size is a positive magnitude despite the negative price (abs-based).+ assert order.size == pytest.approx(0.5 * 1_000_000 / 5.0)+ # Margin (collateral) is positive, not negated by the negative price.+ assert order.margin == pytest.approx(order.size * 5.0)+ assert order.cost > 0+++def test_default_still_rejects_negative_open() -> None:+ eng = _engine(allow=False)+ df, ts = _bar_df(-5.0)+ assert eng._plan_open_order("POWER-DA-DELU", 0.5, df, ts, equity=1_000_000) is None+++def test_zero_price_rejected_even_when_allowed() -> None:+ """DELU 2025-10-26 cleared at exactly 0 — undefined sizing, always rejected."""+ eng = _engine(allow=True)+ df, ts = _bar_df(0.0)+ assert eng._plan_open_order("POWER-DA-DELU", 0.5, df, ts, equity=1_000_000) is None+++def test_margin_and_pnl_well_defined_through_zero() -> None:+ """Collateral positive at a negative entry; PnL correct crossing zero."""+ eng = _engine(allow=True)+ size = 1_000.0+ margin = eng._calc_margin("POWER-DA-DELU", size, price=-5.0, leverage=1.0)+ assert margin == pytest.approx(5_000.0) # abs(price), positive collateral++ # Long from -5 to +3: gains the full 8 EUR/MWh move.+ long_pnl = eng._calc_pnl("POWER-DA-DELU", 1, size, entry_price=-5.0, exit_price=3.0)+ assert long_pnl == pytest.approx(size * 8.0)+ # Short from -5 to -8 (price falls further negative): profits.+ short_pnl = eng._calc_pnl("POWER-DA-DELU", -1, size, entry_price=-5.0, exit_price=-8.0)+ assert short_pnl == pytest.approx(size * 3.0)+++def test_raw_size_positive_for_negative_price() -> None:+ eng = _engine(allow=True)+ size = eng._calc_raw_size("POWER-DA-DELU", target_notional=500_000.0, price=-5.0)+ assert size == pytest.approx(100_000.0) # not -100_000