openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/portfolio/stats.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+import pandas as pd
+
+from openbacktesting.broker.models import finite
+from openbacktesting.data.core import _data_period
+from openbacktesting.indicators.types import IndicatorHandle
+from openbacktesting.portfolio.rates import validate_risk_free_rate
+
+if TYPE_CHECKING:
+    from openbacktesting.broker.core import Trade
+    from openbacktesting.strategy.base import Strategy
+
+
+def compute_drawdown_duration_peaks(dd: pd.Series):
+    iloc = np.unique(
+        np.r_[[-1] if dd.iloc[0] > 0 else [], (dd == 0).values.nonzero()[0], len(dd) - 1]
+    )
+    iloc = pd.Series(iloc.astype(np.intp))
+    df = iloc.to_frame("iloc").assign(prev=iloc.shift())
+    df = df[(df["iloc"] > df["prev"] + 1) | (df["prev"] == -1)].astype(np.int64)
+
+    # If no drawdown since no trade, avoid below for pandas sake and return nan series
+    if not len(df):
+        return (dd.replace(0, np.nan),) * 2
+
+    df["duration"] = df["iloc"].map(dd.index.__getitem__) - df["prev"].clip(lower=0).map(
+        dd.index.__getitem__
+    )
+    df["peak_dd"] = df.apply(
+        lambda row: dd.iloc[max(0, row["prev"]) : row["iloc"] + 1].max(), axis=1
+    )
+    df.index = dd.index[df["iloc"]]
+    df = df.reindex(dd.index)
+    return df["duration"], df["peak_dd"]
+
+
+def geometric_mean(returns: pd.Series) -> float:
+    returns = returns.fillna(0) + 1
+    if np.any(returns <= 0):
+        return 0
+    return np.exp(np.log(returns).sum() / (len(returns) or np.nan)) - 1
+
+
+def compute_stats(
+    trades: list[Trade] | pd.DataFrame,
+    equity: np.ndarray,
+    ohlc_data: pd.DataFrame,
+    strategy_instance: Strategy | None,
+    risk_free_rate: float = 0,
+    exposure: np.ndarray | None = None,
+    initial_equity: float = cast(float, ...),
+) -> pd.Series:
+    risk_free_rate = validate_risk_free_rate(risk_free_rate)
+    initial_equity = finite(
+        equity[0] if initial_equity is Ellipsis else initial_equity,
+        "initial_equity",
+        positive=True,
+    )
+
+    index = ohlc_data.index
+    dd = 1 - equity / np.maximum(initial_equity, np.maximum.accumulate(equity))
+    dd_dur, dd_peaks = compute_drawdown_duration_peaks(pd.Series(dd, index=index))
+
+    equity_df = pd.DataFrame(
+        {"Equity": equity, "DrawdownPct": dd, "DrawdownDuration": dd_dur}, index=index
+    )
+
+    if isinstance(trades, pd.DataFrame):
+        trades_df: pd.DataFrame = trades
+        commissions = None  # Not shown
+    else:
+        # Came straight from Backtest.run()
+        trades_df = pd.DataFrame(
+            {
+                "Size": [t.size for t in trades],
+                "EntryBar": [t.entry_bar for t in trades],
+                "ExitBar": [t.exit_bar for t in trades],
+                "EntryPrice": [t.entry_price for t in trades],
+                "ExitPrice": [t.exit_price for t in trades],
+                "SL": [t.sl for t in trades],
+                "TP": [t.tp for t in trades],
+                "PnL": [t.pl for t in trades],
+                "Commission": [t._commissions for t in trades],
+                "ReturnPct": [t.return_fraction for t in trades],
+                "EntryTime": [t.entry_time for t in trades],
+                "ExitTime": [t.exit_time for t in trades],
+            }
+        )
+        trades_df["Duration"] = trades_df["ExitTime"] - trades_df["EntryTime"]
+        trades_df["Tag"] = [t.tag for t in trades]
+
+        # Add indicator values
+        if len(trades_df) and strategy_instance:
+            for ind in strategy_instance._indicators:
+                name = ind.name
+                ind = np.atleast_2d(ind._view() if isinstance(ind, IndicatorHandle) else ind)
+                for i, values in enumerate(ind):  # multi-d indicators
+                    suffix = f"_{i}" if len(ind) > 1 else ""
+                    trades_df[f"Entry_{name}{suffix}"] = values[trades_df["EntryBar"].values]
+                    trades_df[f"Exit_{name}{suffix}"] = values[trades_df["ExitBar"].values]
+
+        commissions = sum(t._commissions for t in trades)
+    del trades
+
+    pl = trades_df["PnL"]
+    returns = trades_df["ReturnPct"]
+    durations = trades_df["Duration"]
+
+    def _round_timedelta(value, _period=_data_period(index)):  # noqa: B008 — freeze defaults at initialization, preserving native behavior
+        if not isinstance(value, pd.Timedelta) or pd.isna(_period):
+            return value
+        resolution = getattr(_period, "resolution_string", None) or _period.resolution
+        return value.ceil(resolution)
+
+    s = {}
+    s["Start"] = index[0]
+    s["End"] = index[-1]
+    s["Duration"] = s["End"] - s["Start"]
+
+    s["Exposure Time [%]"] = np.nan if exposure is None else exposure.mean() * 100
+    s["Equity Final [$]"] = equity[-1]
+    s["Equity Peak [$]"] = max(initial_equity, equity.max())
+    if commissions:
+        s["Commissions [$]"] = commissions
+    s["Return [%]"] = (equity[-1] - initial_equity) / initial_equity * 100
+    c = ohlc_data.Close.values
+    s["Buy & Hold Return [%]"] = (c[-1] - c[0]) / c[0] * 100
+
+    gmean_day_return: float = 0
+    day_returns = np.array(np.nan)
+    annual_trading_days = np.nan
+    is_datetime_index = isinstance(index, pd.DatetimeIndex)
+    if is_datetime_index:
+        freq_days = cast(pd.Timedelta, _data_period(index)).days
+        have_weekends = index.dayofweek.to_series().between(5, 6).mean() > 2 / 7 * 0.6
+        annual_trading_days = (
+            52
+            if freq_days == 7
+            else 12
+            if freq_days == 31
+            else 1
+            if freq_days == 365
+            else (365 if have_weekends else 252)
+        )
+        freq = {7: "W", 31: "ME", 365: "YE"}.get(freq_days, "D")
+        period_equity = equity_df["Equity"].resample(freq).last().dropna()
+        day_returns = period_equity.pct_change()
+        day_returns.iloc[0] = period_equity.iloc[0] / initial_equity - 1
+        gmean_day_return = geometric_mean(day_returns)
+
+    # Annualized return and risk metrics are computed based on the (mostly correct)
+    # assumption that the returns are compounded. See: https://dx.doi.org/10.2139/ssrn.3054517
+    # Our annualized return matches `empyrical.annual_return(day_returns)` whereas
+    # our risk doesn't; they use the simpler approach below.
+    annualized_return = (1 + gmean_day_return) ** annual_trading_days - 1
+    s["Return (Ann.) [%]"] = annualized_return * 100
+    s["Volatility (Ann.) [%]"] = (
+        np.sqrt(
+            (day_returns.var(ddof=int(bool(day_returns.shape))) + (1 + gmean_day_return) ** 2)
+            ** annual_trading_days
+            - (1 + gmean_day_return) ** (2 * annual_trading_days)
+        )
+        * 100
+    )
+    # d['Return (Ann.) [%]'] = gmean_day_return * annual_trading_days * 100
+    # d['Risk (Ann.) [%]'] = day_returns.std(ddof=1) * np.sqrt(annual_trading_days) * 100
+    if is_datetime_index:
+        time_in_years = (s["Duration"].days + s["Duration"].seconds / 86400) / 365.25
+        s["CAGR [%]"] = (
+            ((s["Equity Final [$]"] / initial_equity) ** (1 / time_in_years) - 1) * 100
+            if time_in_years and equity[-1] > 0
+            else np.nan
+        )
+
+    # Our Sharpe mismatches `empyrical.sharpe_ratio()` because they use arithmetic mean return
+    # and simple standard deviation
+    s["Sharpe Ratio"] = (s["Return (Ann.) [%]"] - risk_free_rate * 100) / (
+        s["Volatility (Ann.) [%]"] or np.nan
+    )
+    # Our Sortino mismatches `empyrical.sortino_ratio()` because they use arithmetic mean return
+    with np.errstate(divide="ignore"):
+        s["Sortino Ratio"] = (annualized_return - risk_free_rate) / (
+            np.sqrt(np.mean(day_returns.clip(-np.inf, 0) ** 2)) * np.sqrt(annual_trading_days)
+        )
+    max_dd = -np.nan_to_num(dd.max())
+    s["Calmar Ratio"] = annualized_return / (-max_dd or np.nan)
+    with np.errstate(divide="ignore", invalid="ignore"):  # Preserve deficits instead of forcing them to zero
+        equity_log_returns = np.log(equity[1:] / equity[:-1])
+    market_log_returns = np.log(c[1:] / c[:-1])
+    beta = np.nan
+    if len(equity_log_returns) > 1 and len(market_log_returns) > 1:
+        # len == 0 on dummy call `stats_keys = compute_stats(...)` pre optimization
+        cov_matrix = np.cov(equity_log_returns, market_log_returns)
+        beta = cov_matrix[0, 1] / cov_matrix[1, 1]
+    # Jensen CAPM Alpha: can be strongly positive when beta is negative and B&H Return is large
+    s["Alpha [%]"] = (
+        s["Return [%]"]
+        - risk_free_rate * 100
+        - beta * (s["Buy & Hold Return [%]"] - risk_free_rate * 100)
+    )
+    s["Beta"] = beta
+    s["Max. Drawdown [%]"] = max_dd * 100
+    s["Avg. Drawdown [%]"] = -dd_peaks.mean() * 100
+    s["Max. Drawdown Duration"] = _round_timedelta(dd_dur.max())
+    s["Avg. Drawdown Duration"] = _round_timedelta(dd_dur.mean())
+    s["# Trades"] = n_trades = len(trades_df)
+    win_rate = np.nan if not n_trades else (pl > 0).mean()
+    s["Win Rate [%]"] = win_rate * 100
+    s["Best Trade [%]"] = returns.max() * 100
+    s["Worst Trade [%]"] = returns.min() * 100
+    mean_return = geometric_mean(returns)
+    s["Avg. Trade [%]"] = mean_return * 100
+    s["Max. Trade Duration"] = _round_timedelta(durations.max())
+    s["Avg. Trade Duration"] = _round_timedelta(durations.mean())
+    s["Profit Factor"] = returns[returns > 0].sum() / (abs(returns[returns < 0].sum()) or np.nan)
+    s["Expectancy [%]"] = returns.mean() * 100
+    s["SQN"] = np.sqrt(n_trades) * pl.mean() / (pl.std() or np.nan)
+    s["Kelly Criterion"] = win_rate - (1 - win_rate) / (pl[pl > 0].mean() / -pl[pl < 0].mean())
+
+    s["_strategy"] = strategy_instance
+    s["_equity_curve"] = equity_df
+    s["_trades"] = trades_df
+
+    s = _Stats(s, dtype=object)
+    s.attrs["statistics_initial_equity"] = initial_equity
+    return s
+
+
+class _Stats(pd.Series):
+    def __repr__(self):
+        with pd.option_context(
+            "display.max_colwidth",
+            20,  # Prevent expansion due to _equity and _trades dfs
+            "display.max_rows",
+            len(self),  # Reveal self whole
+            "display.precision",
+            5,  # Enough for my eyes at least
+        ):
+            # XXX: .fillna(nan) to replace None which aren't na_rep'd otherwise (pandas 3.0).
+            #   Replace with proper na_rep option when that becomes available.
+            #   https://github.com/pandas-dev/pandas/issues/66407
+            return super().fillna(np.nan).to_string(na_rep="--", dtype=True)
+
+
+def dummy_stats():
+    from openbacktesting.broker.core import Trade, _Broker
+
+    index = pd.DatetimeIndex(["2025"])
+    data = pd.DataFrame({col: [np.nan] for col in ("Close",)}, index=index)
+    trade = Trade(
+        _Broker(
+            data=data,
+            cash=10000,
+            spread=0.01,
+            commission=0.01,
+            margin=0.1,
+            hedging=True,
+            exclusive_orders=False,
+            index=index,
+        ),
+        1,
+        1,
+        0,
+        None,
+    )
+    trade.exit_price, trade.exit_bar = 1, 0
+    trade._exit_commission = np.nan
+    return compute_stats([trade], np.r_[[1.0]], data, None, 0, initial_equity=1.0)

openbacktesting/portfolio/trades.py

@@ -0,0 +1,136 @@
+"""Report projections of orders, allocations, and lots without live objects."""
+
+import json
+
+import pandas as pd
+
+from openbacktesting.portfolio.models import plain, time_ref
+
+
+def signal(tag):
+    if isinstance(tag, str) and tag:
+        return tag, None
+    if isinstance(tag, dict):
+        name = tag.get("signal")
+        comment = tag.get("comment")
+        return (
+            name if isinstance(name, str) and name else None,
+            comment if isinstance(comment, str) else None,
+        )
+    return None, None
+
+
+def excursion(state, quantity, entry_price):
+    return {
+        "mfeMoney": state["mfe"] * quantity,
+        "maeMoney": state["mae"] * quantity,
+        "mfeFraction": state["mfe"] / entry_price,
+        "maeFraction": state["mae"] / entry_price,
+        "mfeBar": state["mfeBar"],
+        "maeBar": state["maeBar"],
+        "coverage": "partial" if state["partial"] else "complete_under_bar_model",
+        "methodId": "sampled_bounds_v1",
+        "reason": "ambiguous_intrabar_order" if state["partial"] else None,
+    }
+
+
+def project_trades(stats, observations):
+    facts = {
+        key: stats[field].astype(object).where(stats[field].notna(), None).to_dict("records")
+        for key, field in (
+            ("orders", "_orders"),
+            ("orderSizing", "_order_sizing"),
+            ("orderEvents", "_order_events"),
+            ("fills", "_fills"),
+            ("allocations", "_trade_allocations"),
+        )
+    }
+    orders = {r["order_id"]: r for r in facts["orders"]}
+    fills = {r["fill_id"]: r for r in facts["fills"]}
+
+    def leg(fill):
+        tag = json.loads(orders[fill["order_id"]]["tag_json"])
+        name, comment = signal(tag)
+        return {
+            "fillId": fill["fill_id"],
+            "orderId": fill["order_id"],
+            "barIndex": fill["bar_index"],
+            "time": time_ref(fill["timestamp"]),
+            "phase": fill["phase"],
+            "sequence": fill["sequence"],
+            "price": fill["price"],
+            "signal": name,
+            "comment": comment,
+        }
+
+    extras = {r["allocation_id"]: r for r in stats["_trades"].to_dict("records")}
+    closed = []
+    cumulative = 0.0
+    for allocation in facts["allocations"]:
+        if allocation["kind"] != "close":
+            continue
+        entry, exit_ = fills[allocation["entry_fill_id"]], fills[allocation["fill_id"]]
+        qty = allocation["qty"]
+        cost = qty * entry["price"]
+        pnl = allocation["realized_pnl_gross"] - allocation["entry_fee"] - allocation["fee"]
+        cumulative += pnl
+        elapsed = exit_["bar_index"] - entry["bar_index"]
+        duration = (
+            (exit_["timestamp"] - entry["timestamp"]).value
+            if isinstance(entry["timestamp"], pd.Timestamp)
+            else None
+        )
+        closed.append(
+            {
+                "fragmentId": allocation["allocation_id"],
+                "lotId": allocation["trade_id"],
+                "displayOrdinal": len(closed) + 1,
+                "direction": "long" if entry["side"] == "buy" else "short",
+                "status": "closed",
+                "entry": leg(entry),
+                "exit": leg(exit_),
+                "quantity": qty,
+                "signedQuantity": qty if entry["side"] == "buy" else -qty,
+                "entryNotional": cost,
+                "exitNotional": qty * exit_["price"],
+                "pnlGross": allocation["realized_pnl_gross"],
+                "pnlNet": pnl,
+                "entryFeeAllocated": allocation["entry_fee"],
+                "exitFee": allocation["fee"],
+                "feeTotal": allocation["entry_fee"] + allocation["fee"],
+                "returnFraction": pnl / cost,
+                "barsElapsed": elapsed,
+                "barsHeld": elapsed + 1,
+                "durationNs": str(duration) if duration is not None else None,
+                "cumulativeClosedPnl": cumulative,
+                "fractionOfInitialCapital": cumulative / stats.attrs["statistics_initial_equity"],
+                "excursion": excursion(
+                    observations.closed[allocation["allocation_id"]], qty, entry["price"]
+                ),
+                "extensions": plain(extras[allocation["allocation_id"]]),
+            }
+        )
+    opened = []
+    for t in stats["_open_trades"].to_dict("records"):
+        entry = fills[t["entry_fill_id"]]
+        opened.append(
+            {
+                "lotId": t["trade_id"],
+                "status": "open",
+                "direction": "long" if t["Size"] > 0 else "short",
+                "entry": leg(entry),
+                "exit": None,
+                "remainingQuantity": abs(t["Size"]),
+                "remainingEntryFee": t["EntryFeeRemaining"],
+                "openPnlGross": t["PnLGross"],
+                "openPnlNet": t["PnL"],
+                "returnFraction": t["ReturnPct"],
+                "markPrice": observations.rows[-1]["price"],
+                "asOf": observations.rows[-1]["observationId"],
+                "excursion": excursion(
+                    observations.lots[t["trade_id"]], abs(t["Size"]), entry["price"]
+                ),
+                "tag": plain(t["Tag"]),
+            }
+        )
+    return facts, closed, opened

openbacktesting/portfolio/trading.py

@@ -0,0 +1,215 @@
+"""Generate plain-value result tables with fixed columns from trading facts."""
+
+from dataclasses import asdict
+from importlib.metadata import version
+
+import numpy as np
+import pandas as pd
+
+from openbacktesting.broker.commission import Commission
+from openbacktesting.broker.models import (
+    AccountSnapshot,
+    Fill,
+    NormalizedOrderRequest,
+    OrderSizingSnapshot,
+    OrderSnapshot,
+    PositionSnapshot,
+    TradeAllocation,
+    columns,
+    record,
+)
+
+_FLOAT_FIELDS = {
+    "value",
+    "reference_price",
+    "budget",
+    "qty",
+    "price",
+    "fee",
+    "filled_qty",
+    "remaining_qty",
+    "avg_fill_price",
+    "limit",
+    "stop",
+    "sl",
+    "tp",
+    "entry_fee",
+    "realized_pnl_gross",
+    "balance",
+    "equity",
+    "unrealized_pnl_gross",
+    "fees_paid",
+    "margin_used",
+    "margin_available",
+    "gross_notional",
+    "net_notional",
+    "net_qty",
+    "gross_qty",
+    "long_qty",
+    "short_qty",
+    "long_avg_price",
+    "short_avg_price",
+    "avg_price",
+    "unrealized_pnl_net",
+    "entry_fees_remaining",
+    "return_fraction",
+    "Size",
+    "EntryPrice",
+    "EntryFeeRemaining",
+    "PnLGross",
+    "PnL",
+    "ReturnPct",
+}
+_INT_FIELDS = {"bar_index", "created_bar", "sequence", "EntryBar"}
+_BOOL_FIELDS = {"triggered", "reduce_only"}
+_OBJECT_FIELDS = {"timestamp", "expires_at", "EntryTime", "Tag"}
+
+
+def _table(rows, *, columns):
+    # Construct columns once with target dtypes; avoid inference followed by per-column conversion/replacement of entire DataFrame blocks.
+    data = {}
+    for name in columns:
+        values = [row.get(name) for row in rows]
+        if name in _FLOAT_FIELDS:
+            data[name] = np.asarray(values, dtype="float64")
+        elif name in _INT_FIELDS:
+            data[name] = np.asarray(values, dtype="int64")
+        elif name in _BOOL_FIELDS:
+            data[name] = np.asarray(values, dtype=bool)
+        elif name in _OBJECT_FIELDS:
+            # Series preserves object dtype; passing arrays directly makes DataFrame infer timestamps/nested tags again.
+            data[name] = pd.Series(values, dtype="object")
+        else:
+            data[name] = pd.array(values, dtype="Int64" if name == "valid_bars" else "string")
+    return pd.DataFrame(data, columns=columns)
+
+
+def trading_results(stats, broker, end_policy):
+    """Attach ledger tables and traceable configuration without reading trade records from _strategy."""
+    original = stats
+    stats = dict(stats)
+    order_columns = (
+        columns(OrderSnapshot)
+        + columns(NormalizedOrderRequest)
+        + ["group_id", "kind", "created_bar"]
+    )
+    stats["_orders"] = _table(
+        [
+            record(o.snapshot)
+            | record(o.request)
+            | {"group_id": o.group_id, "kind": o.kind, "created_bar": o.created_bar}
+            for o in broker.all_orders
+        ],
+        columns=order_columns,
+    )
+    stats["_order_sizing"] = _table(
+        [
+            {"order_id": o.order_id} | record(o.sizing)
+            for o in broker.all_orders
+            if o.sizing is not None
+        ],
+        columns=["order_id"] + columns(OrderSizingSnapshot),
+    )
+    event_columns = ["sequence", "bar_index", "timestamp", "phase"] + columns(OrderSnapshot)
+    stats["_order_events"] = _table(
+        [
+            {
+                "sequence": e.sequence,
+                "bar_index": e.bar_index,
+                "timestamp": e.timestamp,
+                "phase": e.phase,
+            }
+            | record(e.snapshot)
+            for e in broker.events
+        ],
+        columns=event_columns,
+    )
+    for name, records, model in (
+        ("_fills", broker.fills, Fill),
+        ("_trade_allocations", broker.allocations, TradeAllocation),
+    ):
+        stats[name] = _table([record(item) for item in records], columns=columns(model))
+    prefix = ["bar_index", "timestamp", "phase"]
+    stats["_positions"] = _table(broker.position_curve, columns=prefix + columns(PositionSnapshot))
+    stats["_account_curve"] = _table(
+        broker.account_curve, columns=prefix + columns(AccountSnapshot)
+    )
+    stats["_final_account"] = record(broker.account)
+    stats["_open_trades"] = _table(
+        [
+            {
+                "trade_id": t.trade_id,
+                "entry_fill_id": t.entry_fill_id,
+                "Size": t.size,
+                "EntryPrice": t.entry_price,
+                "EntryBar": t.entry_bar,
+                "EntryTime": t.entry_time,
+                "EntryFeeRemaining": t._entry_commission,
+                "PnLGross": t.pl_gross,
+                "PnL": t.pl,
+                "ReturnPct": t.return_fraction,
+                "Tag": t.tag,
+            }
+            for t in broker.trades
+        ],
+        columns=[
+            "trade_id",
+            "entry_fill_id",
+            "Size",
+            "EntryPrice",
+            "EntryBar",
+            "EntryTime",
+            "EntryFeeRemaining",
+            "PnLGross",
+            "PnL",
+            "ReturnPct",
+            "Tag",
+        ],
+    )
+    stats["_trades"]["trade_id"] = pd.Series(
+        [t.trade_id for t in broker.closed_trades], dtype="string"
+    )
+    stats["_trades"]["entry_fill_id"] = pd.Series(
+        [t.entry_fill_id for t in broker.closed_trades], dtype="string"
+    )
+    for name in ("allocation_id", "exit_fill_id", "exit_sequence"):
+        stats["_trades"][name] = pd.Series(
+            [getattr(t, name) for t in broker.closed_trades],
+            dtype="int64" if name == "exit_sequence" else "string",
+        )
+    stats["Commissions [$]"] = broker.ledger.fees_paid
+    stats["# Closed Lots"] = len(
+        {t.trade_id for t in broker.closed_trades} - {t.trade_id for t in broker.trades}
+    )
+    commission = broker._commission_model
+    if isinstance(commission, Commission):
+        commission = commission.snapshot()
+    elif callable(commission):
+        commission = {
+            "reconstructable": False,
+            "name": getattr(commission, "__qualname__", type(commission).__name__),
+        }
+        broker.diagnostics.append({"code": "commission_not_reconstructable"})
+    result = type(original)(stats, dtype=object)
+    result.attrs.update(original.attrs)
+    result.attrs.update(
+        {
+            "trading_schema_version": 4,
+            "execution_policy_version": "2",
+            "engine_version": version("openbacktesting"),
+            "instrument": asdict(broker.instrument),
+            "account_model": "linear_margin",
+            "execution_timing": broker.execution_timing,
+            "end_policy": end_policy,
+            "commission": commission,
+            "spread": broker._spread,
+            "slippage": asdict(broker.slippage),
+            "margin": broker.margin,
+            "allow_short": broker.allow_short,
+            "max_gross_exposure": broker.max_gross_exposure,
+            "hedging": broker._hedging,
+            "diagnostics": list(broker.diagnostics),
+        }
+    )
+
+    return result