riskkit-quant 0.4.0__py3-none-any.whl

riskkit/__init__.py

@@ -0,0 +1,86 @@
+"""riskkit — a framework-agnostic risk-management toolkit for systematic traders.
+
+riskkit is the layer most backtesters and trading bots leave thin: how big a
+position to take, where stops live, when to cut size, what not to stack, and
+when to stop trading altogether. Every component is plain Python that knows
+nothing about any exchange, data provider, or backtesting framework — you feed
+it numbers and it hands back auditable decisions.
+
+Components
+----------
+- :class:`PositionSizer`     — volatility-adjusted sizing with a Kelly ceiling
+- :class:`DrawdownManager`   — drawdown-tiered size reduction + halt
+- :class:`StopEngine`        — composable stop stack (initial/BE/trail/time/vol)
+- :class:`CorrelationGuard`  — one open position per correlation group
+- :class:`SessionManager`    — daily limits, cooldowns, tilt detection
+- :class:`PreTradeValidator` — the composable final gate before an order
+
+Quick start::
+
+    from riskkit import PositionSizer, SizingInputs
+
+    sizer = PositionSizer(base_risk_pct=1.0, max_notional_pct=4.0)
+    result = sizer.size(SizingInputs(
+        equity=10_000, entry_price=100, stop_price=98,
+        atr=2.0, atr_baseline=2.0,
+    ))
+    print(result.units, result.risk_pct)
+"""
+from __future__ import annotations
+
+from .correlation import CorrelationDecision, CorrelationGuard
+from .drawdown import DrawdownManager, DrawdownState
+from .manager import OpenPosition, RiskConfig, RiskDecision, RiskManager, TradeIntent
+from .metrics import conditional_value_at_risk, value_at_risk
+from .session import SessionDecision, SessionManager, TradeRecord
+from .sizing import (
+    PositionSizer,
+    SizingInputs,
+    SizingResult,
+    inverse_vol_weights,
+    kelly_fraction,
+    volatility_target_size,
+)
+from .stops import Side, StopEngine, StopStack
+from .validator import CheckResult, PreTradeValidator, TradeProposal, ValidationResult
+
+__version__ = "0.4.0"
+
+__all__ = [
+    # façade
+    "RiskManager",
+    "RiskConfig",
+    "TradeIntent",
+    "RiskDecision",
+    "OpenPosition",
+    # sizing
+    "PositionSizer",
+    "SizingInputs",
+    "SizingResult",
+    "kelly_fraction",
+    "volatility_target_size",
+    "inverse_vol_weights",
+    # drawdown
+    "DrawdownManager",
+    "DrawdownState",
+    # stops
+    "StopEngine",
+    "StopStack",
+    "Side",
+    # correlation
+    "CorrelationGuard",
+    "CorrelationDecision",
+    # session
+    "SessionManager",
+    "SessionDecision",
+    "TradeRecord",
+    # validator
+    "PreTradeValidator",
+    "TradeProposal",
+    "ValidationResult",
+    "CheckResult",
+    # metrics
+    "value_at_risk",
+    "conditional_value_at_risk",
+    "__version__",
+]

riskkit/adapters/__init__.py

@@ -0,0 +1,7 @@
+"""First-class adapters that drop riskkit into popular backtesting frameworks.
+
+Each adapter lives in its own module and imports its framework lazily, so the
+riskkit core stays dependency-free. Import the one you need directly::
+
+    from riskkit.adapters.backtesting import RiskkitStrategy
+"""

riskkit/adapters/backtesting.py

@@ -0,0 +1,165 @@
+"""backtesting.py adapter — risk-managed entries via a Strategy mixin.
+
+`RiskkitStrategy` wires a :class:`riskkit.RiskManager` into a
+`backtesting.py <https://kernc.github.io/backtesting.py/>`_ strategy. Subclass it,
+write your signal logic in ``next()`` as usual, and call :meth:`risk_long` /
+:meth:`risk_short` instead of ``self.buy`` / ``self.sell``. Every entry is then
+sized and validated by your single ``RiskConfig`` — drawdown laddering, session
+caps, correlation/exposure limits, and the pre-trade checklist all apply, and the
+result is converted into a backtesting.py order for you.
+
+Closed trades are fed back into the session manager automatically, so streaks,
+cooldowns, and the daily-loss state are live during the backtest — a drawdown
+that crosses your halt threshold will stop new entries, exactly as it would in
+production.
+
+Requires backtesting.py:  ``pip install "riskkit[backtesting]"``
+
+Example::
+
+    from riskkit import RiskConfig
+    from riskkit.adapters.backtesting import RiskkitStrategy
+    from backtesting import Backtest
+    from backtesting.lib import crossover
+    from backtesting.test import GOOG, SMA
+
+    class SmaCross(RiskkitStrategy):
+        risk_config = RiskConfig(base_risk_pct=2.0, max_notional_pct=15.0)
+
+        def init(self):
+            self.fast = self.I(SMA, self.data.Close, 10)
+            self.slow = self.I(SMA, self.data.Close, 30)
+
+        def next(self):
+            price = self.data.Close[-1]
+            if crossover(self.fast, self.slow) and not self.position:
+                self.risk_long(stop_price=price * 0.97, target_price=price * 1.06)
+            elif crossover(self.slow, self.fast) and self.position:
+                self.position.close()
+
+    Backtest(GOOG, SmaCross, cash=100_000, commission=0.002).run()
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+from backtesting import Strategy
+
+from ..manager import RiskConfig, RiskDecision, RiskManager, TradeIntent
+from ..session import TradeRecord
+
+
+class RiskkitStrategy(Strategy):
+    """A backtesting.py ``Strategy`` mixin that routes entries through riskkit.
+
+    Override these class attributes to configure it:
+
+    - ``risk_config``       — the :class:`~riskkit.RiskConfig` for this strategy.
+    - ``risk_symbol``       — symbol used for correlation grouping (default ``"ASSET"``).
+    - ``risk_strategy``     — strategy name recorded on trades (default ``"default"``).
+    - ``risk_max_fraction`` — cap on the equity fraction sent to one order
+      (default ``0.99``; backtesting.py cannot invest more than available cash).
+    """
+
+    risk_config: RiskConfig | None = None
+    risk_symbol: str = "ASSET"
+    risk_strategy: str = "default"
+    risk_max_fraction: float = 0.99
+
+    def init(self) -> None:
+        """No-op by default — override to declare your indicators."""
+
+    # ------------------------------------------------------------------ internals
+
+    @property
+    def risk(self) -> RiskManager:
+        """The :class:`~riskkit.RiskManager`, created lazily on first use."""
+        mgr = getattr(self, "_risk_mgr", None)
+        if mgr is None:
+            mgr = self._risk_mgr = RiskManager(self.risk_config or RiskConfig())
+            self._closed_seen = 0
+        return mgr
+
+    def _now(self) -> datetime | None:
+        ts = self.data.index[-1]
+        return ts if isinstance(ts, datetime) else None
+
+    def _ingest_closed(self) -> None:
+        """Feed any newly-closed backtesting.py trades into the session manager."""
+        mgr = self.risk
+        trades = self.closed_trades
+        equity = float(self.equity)
+        while self._closed_seen < len(trades):
+            t = trades[self._closed_seen]
+            self._closed_seen += 1
+            duration = 0.0
+            if isinstance(t.entry_time, datetime) and isinstance(t.exit_time, datetime):
+                duration = (t.exit_time - t.entry_time).total_seconds() / 60.0
+            mgr.on_close(
+                TradeRecord(
+                    ts_open=t.entry_time, ts_close=t.exit_time,
+                    pnl=float(t.pl), pnl_pct=float(t.pl_pct) * 100.0,
+                    score=100, position_size_units=abs(float(t.size)),
+                    duration_minutes=duration,
+                    side="long" if t.is_long else "short",
+                    symbol=self.risk_symbol, strategy=self.risk_strategy,
+                ),
+                equity_before=equity,
+            )
+
+    def _enter(
+        self, side: str, entry_price, stop_price, target_price,
+        score: int, atr: float, atr_baseline: float, intent_kwargs: dict,
+    ) -> RiskDecision:
+        now = self._now()
+        self._ingest_closed()                  # reflect any closes before we size
+        equity = float(self.equity)
+        self.risk.on_equity(equity, now=now)
+        price = float(self.data.Close[-1] if entry_price is None else entry_price)
+
+        decision = self.risk.evaluate(
+            TradeIntent(
+                symbol=self.risk_symbol, side=side,
+                entry_price=price, stop_price=float(stop_price),
+                target_price=float(target_price), score=score,
+                atr=atr, atr_baseline=atr_baseline, **intent_kwargs,
+            ),
+            now=now,
+        )
+
+        if decision.ok and equity > 0:
+            fraction = min(self.risk_max_fraction, decision.notional / equity)
+            if fraction > 0:
+                place = self.buy if side == "long" else self.sell
+                place(size=fraction, sl=float(stop_price), tp=float(target_price))
+                self.risk.on_fill(decision, strategy=self.risk_strategy)
+        return decision
+
+    # ------------------------------------------------------------------ public API
+
+    def risk_long(
+        self, *, stop_price, target_price, entry_price=None,
+        score: int = 100, atr: float = 0.0, atr_baseline: float = 0.0,
+        **intent_kwargs,
+    ) -> RiskDecision:
+        """Attempt a risk-sized, validated long. Returns the :class:`RiskDecision`.
+
+        ``entry_price`` defaults to the current close. Extra keyword arguments are
+        forwarded to :class:`~riskkit.TradeIntent` (e.g. ``win_rate`` for Kelly,
+        ``spread_pct`` for the market-quality gate).
+        """
+        return self._enter(
+            "long", entry_price, stop_price, target_price,
+            score, atr, atr_baseline, intent_kwargs,
+        )
+
+    def risk_short(
+        self, *, stop_price, target_price, entry_price=None,
+        score: int = 100, atr: float = 0.0, atr_baseline: float = 0.0,
+        **intent_kwargs,
+    ) -> RiskDecision:
+        """Attempt a risk-sized, validated short. Returns the :class:`RiskDecision`."""
+        return self._enter(
+            "short", entry_price, stop_price, target_price,
+            score, atr, atr_baseline, intent_kwargs,
+        )

riskkit/adapters/freqtrade.py

@@ -0,0 +1,144 @@
+"""freqtrade adapter — risk-managed staking and entry vetoes.
+
+freqtrade strategies are composition-friendly: keep your signals in
+``populate_*`` and let this helper drive sizing and the entry gate from the
+strategy callbacks. ``FreqtradeRiskManager`` imports **nothing** from freqtrade —
+you pass it the values freqtrade hands your callbacks, and it returns what those
+callbacks should return. That keeps the riskkit core dependency-free and means
+the adapter is fully unit-testable without installing freqtrade.
+
+Wire it into your ``IStrategy`` like this::
+
+    from riskkit import RiskConfig
+    from riskkit.adapters.freqtrade import FreqtradeRiskManager
+
+    class MyStrategy(IStrategy):
+        def bot_start(self):
+            self.risk = FreqtradeRiskManager(RiskConfig.balanced())
+
+        def custom_stake_amount(self, pair, current_time, current_rate,
+                                proposed_stake, min_stake, max_stake,
+                                leverage, entry_tag, side, **kwargs):
+            info = self.custom_info[pair]
+            return self.risk.stake_amount(
+                pair=pair, side=side,
+                equity=self.wallets.get_total_stake_amount(),
+                current_rate=current_rate,
+                stop_price=info["stop_price"],
+                max_stake=max_stake, min_stake=min_stake,
+                score=info.get("score", 100),
+                atr=info.get("atr", 0.0), atr_baseline=info.get("atr_baseline", 0.0),
+                now=current_time,
+            )
+
+        def confirm_trade_entry(self, pair, *args, **kwargs):
+            allowed = self.risk.confirm_entry(pair)
+            if allowed:
+                self.risk.on_fill(pair)        # register it in the open book
+            return allowed
+
+A returned stake of ``0.0`` tells freqtrade to skip the entry, so sizing and the
+veto can both live in ``custom_stake_amount`` if you prefer a single callback.
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+from ..manager import RiskConfig, RiskDecision, RiskManager, TradeIntent
+from ..session import TradeRecord
+
+
+class FreqtradeRiskManager:
+    """Drives a :class:`~riskkit.RiskManager` from freqtrade's callback signatures.
+
+    For cross-pair features (correlation, total exposure, concurrency) to work,
+    call :meth:`on_fill` once an entry is confirmed and :meth:`on_exit` when a
+    trade closes, so the open book and session state stay current.
+    """
+
+    def __init__(self, config: RiskConfig | None = None) -> None:
+        self.risk = RiskManager(config or RiskConfig())
+        self._last: dict[str, RiskDecision] = {}
+
+    # ------------------------------------------------------------------ entry
+
+    def stake_amount(
+        self, *, pair: str, equity: float, current_rate: float, stop_price: float,
+        max_stake: float, min_stake: float = 0.0, target_price: float | None = None,
+        side: str = "long", score: int = 100, now: datetime | None = None,
+        **intent_kwargs,
+    ) -> float:
+        """Riskkit-sized stake (quote currency) for ``custom_stake_amount``.
+
+        Returns ``0.0`` when riskkit vetoes the entry or the size would fall below
+        ``min_stake`` — both of which make freqtrade skip the trade. The result is
+        also cached so :meth:`confirm_entry` can mirror the same decision.
+
+        ``target_price`` is optional: freqtrade trades are usually exited by ROI /
+        trailing stops rather than a fixed target, so when it is omitted a target
+        that exactly meets the configured minimum reward:risk is assumed (the R:R
+        gate stays neutral). Extra keyword arguments flow to :class:`TradeIntent`.
+        """
+        if target_price is None:
+            risk = abs(current_rate - stop_price)
+            rr = self.risk.validator.min_rr
+            target_price = (
+                current_rate + rr * risk if side == "long" else current_rate - rr * risk
+            )
+
+        self.risk.on_equity(equity, now=now)
+        decision = self.risk.evaluate(
+            TradeIntent(
+                symbol=pair, side=side, entry_price=current_rate,
+                stop_price=stop_price, target_price=target_price,
+                score=score, **intent_kwargs,
+            ),
+            now=now,
+        )
+        self._last[pair] = decision
+        if not decision.ok:
+            return 0.0
+
+        stake = decision.notional
+        if max_stake:
+            stake = min(stake, float(max_stake))
+        if min_stake and stake < float(min_stake):
+            return 0.0
+        return stake
+
+    def confirm_entry(self, pair: str) -> bool:
+        """Mirror the cached decision in ``confirm_trade_entry``. ``True`` allows it."""
+        decision = self._last.get(pair)
+        return bool(decision and decision.ok)
+
+    def last_decision(self, pair: str) -> RiskDecision | None:
+        """The most recent :class:`RiskDecision` for ``pair`` (e.g. to log veto reasons)."""
+        return self._last.get(pair)
+
+    # ------------------------------------------------------------------ book
+
+    def on_fill(self, pair: str) -> None:
+        """Register a confirmed entry in the open book (call after confirmation)."""
+        decision = self._last.get(pair)
+        if decision and decision.ok:
+            self.risk.on_fill(decision)
+
+    def on_exit(
+        self, *, pair: str, pnl: float, pnl_pct: float,
+        open_time: datetime, close_time: datetime, amount: float = 0.0,
+        side: str = "long", strategy: str = "default",
+        equity_before: float | None = None,
+    ) -> None:
+        """Feed a closed trade back to the session manager (streaks, cooldowns, day P&L)."""
+        duration = 0.0
+        if isinstance(open_time, datetime) and isinstance(close_time, datetime):
+            duration = (close_time - open_time).total_seconds() / 60.0
+        self.risk.on_close(
+            TradeRecord(
+                ts_open=open_time, ts_close=close_time,
+                pnl=pnl, pnl_pct=pnl_pct, score=100,
+                position_size_units=abs(amount), duration_minutes=duration,
+                side=side, symbol=pair, strategy=strategy,
+            ),
+            equity_before=equity_before,
+        )

riskkit/adapters/vectorbt.py

@@ -0,0 +1,129 @@
+"""vectorbt adapter — size an array of signals with riskkit.
+
+vectorbt is vectorized; riskkit's drawdown and session guards are inherently
+sequential, so they don't map onto a single vectorized pass. What *does* map
+cleanly is **sizing**: given equity and per-bar entry / stop / volatility, produce
+an array of position sizes to feed vectorbt as ``size=``.
+
+:func:`size_signals` does exactly that. It imports nothing from vectorbt and
+returns a plain list, so it works with ``vbt.Portfolio.from_signals``, your own
+vectorized loop, or pandas. Per-trade drawdown control is supported by passing a
+``drawdown_pct`` series (from whatever equity proxy you have) — it feeds the
+sizer's reduction ladder. The *stateful* guards (drawdown halting, session caps)
+need the sequential :class:`~riskkit.RiskManager`; see the backtesting.py adapter.
+
+Example::
+
+    import vectorbt as vbt
+    from riskkit.adapters.vectorbt import size_signals
+
+    sizes = size_signals(
+        equity=10_000,
+        entry_prices=close.where(entries),     # price where entering, else NaN
+        stop_prices=close * 0.97,
+        atr=atr, atr_baseline=atr.rolling(100).mean(),
+    )
+    pf = vbt.Portfolio.from_signals(close, entries, exits,
+                                    size=sizes, size_type="value")
+"""
+from __future__ import annotations
+
+from math import isnan
+from typing import Sequence
+
+from ..sizing import PositionSizer, SizingInputs
+
+
+def _as_list(value, n: int, name: str) -> list:
+    """Normalize a scalar or sequence to a length-``n`` list (pandas/numpy safe)."""
+    if value is None:
+        return [None] * n
+    if hasattr(value, "__len__") and not isinstance(value, (str, bytes)):
+        seq = list(value)
+        if len(seq) != n:
+            raise ValueError(f"{name} has length {len(seq)}, expected {n}")
+        return seq
+    return [value] * n
+
+
+def _is_entry(price) -> bool:
+    """A bar is an entry where the entry price is present and positive."""
+    if price is None:
+        return False
+    try:
+        if isnan(price):
+            return False
+    except TypeError:
+        return False
+    return price > 0
+
+
+def size_signals(
+    *,
+    equity,
+    entry_prices: Sequence[float],
+    stop_prices: Sequence[float],
+    atr=None,
+    atr_baseline=None,
+    drawdown_pct=None,
+    sizer: PositionSizer | None = None,
+    return_fraction: bool = True,
+) -> list[float]:
+    """Size each entry signal with riskkit's :class:`PositionSizer`.
+
+    Parameters
+    ----------
+    equity:
+        Account equity — a scalar (fixed-fractional on a constant base) or a
+        per-bar sequence (e.g. a rolling equity estimate).
+    entry_prices:
+        Entry price at each bar; use ``NaN`` / ``0`` / ``None`` on bars with no
+        entry. This array drives where a non-zero size is produced.
+    stop_prices:
+        Stop price at each bar (defines risk-per-unit).
+    atr, atr_baseline:
+        Optional volatility and its baseline for the sizer's vol scaling
+        (scalar or per-bar). Omitted ⇒ no vol scaling.
+    drawdown_pct:
+        Optional per-bar drawdown percentage fed to the sizer's reduction ladder.
+    sizer:
+        A configured :class:`PositionSizer` (defaults to ``PositionSizer()``).
+    return_fraction:
+        When ``True`` (default) each element is ``notional / equity`` (use vectorbt
+        ``size_type="value"``/percent); when ``False`` it is units (``"amount"``).
+
+    Returns
+    -------
+    A list the same length as ``entry_prices``: the size on entry bars, ``0.0``
+    elsewhere (and where the sizer vetoes the trade).
+    """
+    sizer = sizer or PositionSizer()
+    n = len(entry_prices)
+    eq = _as_list(equity, n, "equity")
+    entries = list(entry_prices)
+    stops = _as_list(stop_prices, n, "stop_prices")
+    atrs = _as_list(atr, n, "atr")
+    bases = _as_list(atr_baseline, n, "atr_baseline")
+    dds = _as_list(drawdown_pct, n, "drawdown_pct")
+
+    sizes: list[float] = []
+    for i in range(n):
+        entry = entries[i]
+        if not _is_entry(entry) or eq[i] is None or stops[i] is None:
+            sizes.append(0.0)
+            continue
+        result = sizer.size(SizingInputs(
+            equity=float(eq[i]),
+            entry_price=float(entry),
+            stop_price=float(stops[i]),
+            atr=float(atrs[i]) if atrs[i] is not None else 0.0,
+            atr_baseline=float(bases[i]) if bases[i] is not None else 0.0,
+            drawdown_pct=float(dds[i]) if dds[i] is not None else 0.0,
+        ))
+        if result.units <= 0:
+            sizes.append(0.0)
+        elif return_fraction:
+            sizes.append(result.notional / float(eq[i]) if eq[i] else 0.0)
+        else:
+            sizes.append(result.units)
+    return sizes

riskkit/correlation.py

@@ -0,0 +1,119 @@
+"""Correlation guard.
+
+Stops you from stacking the same risk under different names — opening three
+"different" positions that are really one correlated bet. It works from two
+sources:
+
+  1. **Static groups** you define (e.g. instruments you know move together).
+  2. **Dynamic groups** computed from a rolling return correlation matrix.
+
+Rule: at most one open position per correlation group at a time.
+
+The static-group logic is pure Python with no dependencies. The dynamic
+recompute uses pandas, which is an optional extra (``pip install riskkit[pandas]``)
+— import it only if you call :meth:`CorrelationGuard.recompute_dynamic`.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    import pandas as pd
+
+
+@dataclass
+class CorrelationDecision:
+    allowed: bool
+    reason: str = ""
+    blocking_symbol: str | None = None
+    group: str | None = None
+
+
+class CorrelationGuard:
+    """Limit concurrent exposure across correlated instruments.
+
+    Parameters
+    ----------
+    static_groups:
+        Named groups of symbols known to move together. Optional.
+    dynamic_threshold:
+        Absolute return-correlation above which two symbols are grouped
+        dynamically.
+    lookback_days:
+        Rolling window used by :meth:`recompute_dynamic`.
+    """
+
+    def __init__(
+        self,
+        static_groups: Mapping[str, set[str]] | None = None,
+        dynamic_threshold: float = 0.75,
+        lookback_days: int = 30,
+    ) -> None:
+        self.static_groups: dict[str, set[str]] = dict(static_groups or {})
+        self.dynamic_threshold = dynamic_threshold
+        self.lookback_days = lookback_days
+        self._dynamic_groups: list[set[str]] = []
+
+    # ----------------------------------------------------------------- dynamic
+
+    def recompute_dynamic(self, daily_closes: "Mapping[str, pd.Series]") -> None:
+        """Rebuild dynamic groups from a mapping ``symbol -> daily-close Series``.
+
+        Requires pandas (``pip install riskkit[pandas]``).
+        """
+        try:
+            import pandas as pd
+        except ImportError as exc:  # pragma: no cover - exercised without pandas
+            raise ImportError(
+                "recompute_dynamic requires pandas. Install it with "
+                "`pip install riskkit[pandas]`."
+            ) from exc
+
+        symbols = list(daily_closes.keys())
+        if len(symbols) < 2:
+            self._dynamic_groups = []
+            return
+
+        df = pd.DataFrame(
+            {s: daily_closes[s].tail(self.lookback_days * 2) for s in symbols}
+        ).dropna()
+        if len(df) < self.lookback_days // 2:
+            self._dynamic_groups = []
+            return
+
+        corr = df.pct_change().dropna().corr().abs()
+
+        groups: list[set[str]] = []
+        for i, a in enumerate(symbols):
+            for b in symbols[i + 1:]:
+                if a == b or pd.isna(corr.loc[a, b]):
+                    continue
+                if corr.loc[a, b] > self.dynamic_threshold:
+                    for g in groups:
+                        if a in g or b in g:
+                            g.update({a, b})
+                            break
+                    else:
+                        groups.append({a, b})
+        self._dynamic_groups = groups
+
+    # ----------------------------------------------------------------- check
+
+    def can_open(self, symbol: str, open_symbols: set[str]) -> CorrelationDecision:
+        """Return whether ``symbol`` may be opened given the currently open set."""
+        all_groups = list(self.static_groups.items()) + [
+            (f"dynamic_{i}", g) for i, g in enumerate(self._dynamic_groups)
+        ]
+        for name, members in all_groups:
+            if symbol not in members:
+                continue
+            conflict = open_symbols & members
+            if conflict:
+                return CorrelationDecision(
+                    allowed=False,
+                    reason=f"correlated with open position in group '{name}'",
+                    blocking_symbol=sorted(conflict)[0],
+                    group=name,
+                )
+        return CorrelationDecision(allowed=True)