openscript 0.4.0__py3-none-any.whl

openscript/accounting/trades.py

@@ -0,0 +1,294 @@
+"""What a trade is, which is the definition every statistic is counted over.
+
+**A trade is one position reference, from the fill that first takes it away from
+zero to the fill that returns it to zero.** Nothing else is invented, because the
+engine already mints a reference per position, no order crosses zero, and every
+fill names the reference it settled however late it arrives.
+
+Everything awkward falls out of that rather than needing a rule of its own. A
+pyramided entry is more entry fills on one trade. A partial close is an exit fill
+that does not close the trade. A flip is two references and therefore two trades,
+which is what a reversing order already sends. A reference still holding
+something at the last bar is an open trade: it is in the list with ``is_open``
+true, it is counted in equity, and it is counted in no win rate.
+
+**What the fold reads, and what it refuses to work out for itself.** A fill
+carries the signed size of its reference either side of the settlement, so the
+fold reads what the position book did rather than recomputing it from quantities
+and sides. That is the whole of how a partial close, a pyramided entry and a
+reversal tell themselves apart. It also settles the one case the definition does
+not cover on its face: a destination that fills more than the order asked takes a
+reference through zero rather than to it, so the fill closes the trade that was
+held and opens a second one on the same reference, at its own price and on its
+own bar.
+
+**Reducing a position does not move its average**, which is the position book's
+rule read here rather than a second one: a reducing fill adds to the exits and
+touches neither the entry quantity nor the entry cost.
+
+**A charge lands whole on one trade and is never split.** It was rounded once for
+the fill that incurred it, and splitting it would round it again and put a residue
+somewhere. So it is attributed to the trade the fill closed where it closed one,
+and to the trade it opened otherwise, which makes the charges of the trades add
+up to the charges of the fills exactly rather than nearly.
+
+**Gross profit is over the units that have left.** For a closed trade that is
+every unit it entered. For one still open it is what its exits have realised so
+far, which is a figure that is true rather than a zero standing in for money the
+run has already made.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Sequence, Tuple
+
+from .shapes import BarMark, Contract, RecordedFill
+
+
+def _sign(value: float) -> int:
+    """The sign of a size, which is the whole of how a move is read.
+
+    Written here rather than imported from the ledger, because this package
+    imports no engine: a stored record has to be reportable again with no engine
+    present, which is what makes a run record a conformance case rather than a
+    souvenir.
+    """
+    if value > 0:
+        return 1
+    if value < 0:
+        return -1
+    return 0
+
+
+@dataclass(frozen=True)
+class Trade:
+    """One round trip on one position reference."""
+
+    #: 1-based, in the order the trade opened.
+    index: int
+    position_ref: int
+    side: str
+    opened_on_bar: int
+    opened_at: Optional[float]
+    closed_on_bar: Optional[int]
+    closed_at: Optional[float]
+    bars_held: Optional[int]
+    #: Total units entered.
+    units: float
+    #: Quantity weighted over the entry fills.
+    entry_price: float
+    #: Quantity weighted over the exit fills.
+    exit_price: Optional[float]
+    entries: int
+    exits: int
+    gross_profit: float
+    charges: float
+    net_profit: float
+    #: Excursion at bar closes while open. Favourable is zero or better, adverse
+    #: zero or worse, and both are zero for a trade no bar closed on.
+    max_favourable: float
+    max_adverse: float
+    is_open: bool
+
+
+@dataclass
+class _Building:
+    """A trade while it is still being folded: the totals a round trip is made of."""
+
+    index: int
+    position_ref: int
+    side: str
+    opened_on_bar: int
+    opened_at: Optional[float]
+    closed_on_bar: Optional[int] = None
+    closed_at: Optional[float] = None
+    entry_units: float = 0.0
+    entry_cost: float = 0.0
+    exit_units: float = 0.0
+    exit_cost: float = 0.0
+    entries: int = 0
+    exits: int = 0
+    charges: float = 0.0
+    #: Signed, and what the reference holds for this trade right now.
+    size: float = 0.0
+    max_favourable: float = 0.0
+    max_adverse: float = 0.0
+
+
+def closed_by(before: float, after: float) -> float:
+    """How much of a move from one size to another closed what was held.
+
+    A move to the other side of zero closed all of it, which is the case a
+    destination that overfilled produces and the one this has to get right.
+    """
+    if before == 0:
+        return 0.0
+    same = _sign(after) == _sign(before)
+    return max(0.0, abs(before) - abs(after)) if same else abs(before)
+
+
+def opened_by(before: float, after: float) -> float:
+    """And how much of it opened something, which is the rest of the same move."""
+    if after == 0:
+        return 0.0
+    if before == 0 or _sign(after) != _sign(before):
+        return abs(after)
+    return max(0.0, abs(after) - abs(before))
+
+
+def _average_of(cost: float, units: float) -> float:
+    return 0.0 if units == 0 else cost / units
+
+
+def _begin(fill: RecordedFill, units: float, index: int) -> _Building:
+    return _Building(
+        index=index,
+        position_ref=fill.position_ref,
+        side="long" if fill.ref_size_after > 0 else "short",
+        opened_on_bar=fill.bar_index,
+        opened_at=fill.bar_time,
+        entry_units=units,
+        entry_cost=units * fill.price,
+        entries=1,
+        size=fill.ref_size_after,
+    )
+
+
+def _fold(
+    fill: RecordedFill, charge: float, built: List[_Building], live: List[_Building]
+) -> None:
+    """One fill against the trades its reference holds."""
+    closing = closed_by(fill.ref_size_before, fill.ref_size_after)
+    opening = opened_by(fill.ref_size_before, fill.ref_size_after)
+    at = -1
+    for index, trade in enumerate(live):
+        if trade.position_ref == fill.position_ref:
+            at = index
+            break
+    held = None if at < 0 else live[at]
+    paid = False
+
+    if held is not None and closing > 0:
+        held.exit_units += closing
+        held.exit_cost += closing * fill.price
+        held.exits += 1
+        held.charges += charge
+        paid = True
+        # What the reference left this trade holding: nothing at all when the
+        # fill carried it through zero, since the other side of zero is the next
+        # trade.
+        held.size = 0.0 if opening > 0 else fill.ref_size_after
+        if held.size == 0:
+            held.closed_on_bar = fill.bar_index
+            held.closed_at = fill.bar_time
+            del live[at]
+
+    if opening > 0:
+        # A fill that closed something opens a trade of its own rather than
+        # adding to the one it just finished.
+        adding = None if closing > 0 else held
+        if adding is None:
+            fresh = _begin(fill, opening, len(built) + 1)
+            built.append(fresh)
+            live.append(fresh)
+            if not paid:
+                fresh.charges += charge
+        else:
+            adding.entry_units += opening
+            adding.entry_cost += opening * fill.price
+            adding.entries += 1
+            adding.size = fill.ref_size_after
+            if not paid:
+                adding.charges += charge
+        return
+
+    # A fill that moved nothing still cost something, and it cost it on account
+    # of the trade its reference is holding.
+    if not paid and held is not None:
+        held.charges += charge
+
+
+def _mark_to(live: Sequence[_Building], close: float, point_value: float) -> None:
+    """Every open trade against one bar's close."""
+    for trade in live:
+        entry = _average_of(trade.entry_cost, trade.entry_units)
+        excursion = (close - entry) * trade.size * point_value
+        if excursion > trade.max_favourable:
+            trade.max_favourable = excursion
+        if excursion < trade.max_adverse:
+            trade.max_adverse = excursion
+
+
+def _finish(trade: _Building, contract: Contract) -> Trade:
+    entry_price = _average_of(trade.entry_cost, trade.entry_units)
+    exit_price = None if trade.exit_units == 0 else trade.exit_cost / trade.exit_units
+    way = 1 if trade.side == "long" else -1
+    gross = (
+        0.0
+        if exit_price is None
+        else (exit_price - entry_price) * trade.exit_units * contract.point_value * way
+    )
+    return Trade(
+        index=trade.index,
+        position_ref=trade.position_ref,
+        side=trade.side,
+        opened_on_bar=trade.opened_on_bar,
+        opened_at=trade.opened_at,
+        closed_on_bar=trade.closed_on_bar,
+        closed_at=trade.closed_at,
+        bars_held=None if trade.closed_on_bar is None else trade.closed_on_bar - trade.opened_on_bar,
+        units=trade.entry_units,
+        entry_price=entry_price,
+        exit_price=exit_price,
+        entries=trade.entries,
+        exits=trade.exits,
+        gross_profit=gross,
+        charges=trade.charges,
+        net_profit=gross - trade.charges,
+        max_favourable=trade.max_favourable,
+        max_adverse=trade.max_adverse,
+        is_open=trade.closed_on_bar is None,
+    )
+
+
+def trades_of(
+    fills: Sequence[RecordedFill],
+    charges: Sequence[float],
+    marks: Sequence[BarMark],
+    contract: Contract,
+) -> Tuple[Trade, ...]:
+    """The round trips a run's fills make up, in the order they opened.
+
+    ``charges[index]`` is the money ``fills[index]`` was charged, rounded once by
+    whoever computed it, so the two travel as one thing and nothing here rounds
+    anything a second time. A caller with no cost model supplies no charges at all
+    and every trade's charges are zero.
+
+    The fills are read in ``seq`` order whatever order they are handed in, because
+    ``seq`` is the order the engine folded them and a report that depended on the
+    order a caller happened to be holding them in would not be reproducible. The
+    marks are read in bar order for the same reason, and a bar is marked after
+    every fill up to it has been folded, because a fill happens during its bar and
+    the close comes after.
+    """
+    paired = [
+        (fill, charges[index] if index < len(charges) else 0.0)
+        for index, fill in enumerate(fills)
+    ]
+    settled = sorted(paired, key=lambda one: one[0].seq)
+    built: List[_Building] = []
+    live: List[_Building] = []
+
+    at = 0
+    for bar in sorted(marks, key=lambda one: one.bar_index):
+        while at < len(settled) and settled[at][0].bar_index <= bar.bar_index:
+            _fold(settled[at][0], settled[at][1], built, live)
+            at += 1
+        # A bar with no close is not a price anything can be marked at. It marks
+        # nothing rather than marking zero, which would read as a total loss.
+        if bar.close is not None:
+            _mark_to(live, bar.close, contract.point_value)
+    while at < len(settled):
+        _fold(settled[at][0], settled[at][1], built, live)
+        at += 1
+
+    return tuple(_finish(trade, contract) for trade in built)

openscript/adapter/__init__.py

@@ -0,0 +1,32 @@
+"""The conformance adapter: one case in, one JSON object out.
+
+``spec/conformance.md`` section 9 is the whole specification of what is here, and
+``__main__.py`` next door is the command line that starts it. This package is the
+door and holds nothing of its own.
+
+What goes where:
+
+- ``page``          what the conformance page fixes, held to it by a test
+- ``spellings``     how a value is written in a case file and in a report
+- ``reading``       one case directory, by the names section 2's table gives it
+- ``expectations``  what the case's own files expect, as channels
+- ``sessions``      the session facts an engine derives from the record
+- ``facts``         the ``chart``, ``pos`` and session entries, which are not the library's
+- ``ordering``      the nine order calls, and the desk that folds a case's frames
+- ``reporting``     what a strategy run's report was folded under
+- ``channels``      the orders, trades and performance channels, as section 4 writes them
+- ``serving``       the seam between the library's entries and the machine
+- ``running``       the engine's answer for one case, with no comparison made
+- ``matching``      the comparison of section 6, and the caps it is held to
+- ``answers``       the three invocations, each to the object it writes
+
+**Nothing here decides what this engine can do.** The engine refuses what it
+cannot serve, by name, at load; ``running`` turns that refusal into the
+``unsupported`` outcome. A list of unsupported features kept in the adapter would
+say what somebody believed, and would go on saying it after the engine grew the
+feature.
+"""
+
+from .answers import answer_for, describe, invoke, result_for
+
+__all__ = ["answer_for", "describe", "invoke", "result_for"]

openscript/adapter/answers.py

@@ -0,0 +1,215 @@
+"""The three objects ``conformance.md`` section 9 says an adapter writes.
+
+    adapter --describe                  the engine's identity
+    adapter <case-directory>            one case result
+    adapter --actual <case-directory>   the channels the case asserts, no comparison
+
+The third exists so that two engines can be compared with each other rather than
+each with an expected file: a case result carries an outcome and a first
+difference rather than the values, so two adapters reporting ``pass`` prove only
+that both matched a file, which section 10 says is not enough. In that mode this
+adapter makes no comparison, reads no tolerance and reports no outcome.
+
+**This engine implements no compiler, and the program arrives compiled.** Section
+1 covers it: "An implementation that only has an engine (it reads compiled
+programs produced elsewhere) runs the engine half and says so". So the compiled
+program is handed to this process, as the canonical text a host sends it in
+production, and the invocation that carries it is described in ``__main__.py``.
+Two consequences are reported rather than hidden. A case whose assertion is the
+compiler's own diagnostics is ``unsupported``, because those diagnostics are not
+this engine's to claim. And the text goes in through ``load_text``, so the
+canonicity check at the text boundary is exercised on every case rather than
+skipped by handing the engine an object.
+
+**The profile claimed is the page's lowest**, and every case this engine cannot
+run is named on the case with the ``unsupported`` outcome. Section 8 offers
+``engine-only`` for an implementation with no compiler and the runner's own
+vocabulary is the profile table, which does not list it, so the identity carries
+both: the profile the table names, and the flag that says what section 8 would
+have it say. The stage's report records that as a defect of the page rather than
+leaving it to be discovered.
+"""
+
+import json
+import sys
+import tomllib
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ..version import FORMAT, LANGUAGE_VERSIONS
+from .expectations import expected_channels
+from .matching import compare_channels, tolerance_from
+from .page import PROFILES
+from .reading import read_case
+from .running import run_case
+from .spellings import Malformed
+
+#: The distribution file beside the package, which states the version once.
+_PROJECT = "pyproject.toml"
+
+#: Section 8: what this implementation claims. The profile that covers the cases
+#: it runs, which is the one a case it would report ``unsupported`` is not in.
+#:
+#: The claim is read against the runner rather than against the table's own
+#: sentence, and the two do not say the same thing. Section 8 makes a profile
+#: cumulative, so ``strategy`` reads as "everything ``chart`` covers, and orders
+#: as well", and this engine draws nothing: a surface case would be answered
+#: ``unsupported`` naming the channel. The runner's vocabulary is that table, so
+#: the honest alternatives are to claim this and report every channel it cannot
+#: answer by name, or to claim ``core`` and have every strategy case skipped,
+#: which is a suite that proves nothing about the engine that runs the money.
+#: The first is chosen, the shortfall is named on the case rather than in a
+#: footnote, and the stage's report records the page's missing profile as a
+#: defect of the page.
+PROFILE = PROFILES[2]
+
+
+def _distribution() -> Dict[str, Any]:
+    """``pyproject.toml``, read from beside the package, or a refusal saying so.
+
+    The version is a fact of the release and is written in the distribution
+    file; ``scripts/check-python.mjs`` already holds that file and the package
+    manifest equal, so reading it here adds no third copy. An installed package
+    that does not carry the file cannot prove its version, and an identity with
+    an invented version in it is worse than an adapter that says which file it
+    could not find.
+    """
+    path = Path(__file__).resolve().parent.parent.parent / _PROJECT
+    try:
+        with path.open("rb") as file:
+            return tomllib.load(file)["project"]
+    except (OSError, KeyError, ValueError) as reason:
+        raise Malformed(
+            f"{path} could not be read, and section 9 has an adapter answer with the engine's own "
+            f"name and version: {reason}"
+        ) from None
+
+
+def describe() -> Dict[str, Any]:
+    """The identity section 9's table asks for, and the one flag section 8 adds."""
+    project = _distribution()
+    return {
+        "name": project["name"],
+        "version": project["version"],
+        "profile": PROFILE,
+        "languageVersions": list(LANGUAGE_VERSIONS),
+        # The compiled program format this engine implements
+        # (``compiled-program.md`` section 9). Section 9 of the conformance page
+        # names the field and fixes no meaning for it.
+        "schemaVersion": FORMAT,
+        # Section 8: an implementation that runs compiled programs and implements
+        # no compiler reports engine-only, and its report says so.
+        "engineOnly": True,
+    }
+
+
+def _program_from(envelope: Any) -> Any:
+    """The compiled program the invocation carried, or what it carried instead."""
+    if not isinstance(envelope, dict):
+        raise Malformed(
+            "this adapter is handed the compiled program on standard input, as one JSON object, "
+            "and nothing readable arrived"
+        )
+    held = envelope.get("program")
+    if isinstance(held, str):
+        return held
+    if "diagnostics" in envelope:
+        return None
+    raise Malformed(
+        f"the invocation carried neither a program nor the diagnostics of a compile: "
+        f"{sorted(envelope)}"
+    )
+
+
+def answer_for(directory: str, envelope: Any) -> Dict[str, Any]:
+    """``--actual``: what this engine computed, and what it could not compute.
+
+    ``{id, channels, unsupported}``, or ``{id, error}`` for a case that cannot be
+    run at all. No comparison is made and no tolerance is read.
+    """
+    try:
+        case = read_case(directory)
+    except Malformed as reason:
+        return {"id": None, "error": str(reason)}
+    try:
+        program = _program_from(envelope)
+        if program is None:
+            return {
+                "id": case.identity,
+                "channels": {},
+                "unsupported": [
+                    "the compiler (section 1): the case's script did not compile, this engine "
+                    "implements none, and a diagnostic another compiler raised is not this "
+                    "engine's to assert"
+                ],
+            }
+        found = run_case(case, program)
+    except Malformed as reason:
+        return {"id": case.identity, "error": str(reason)}
+    return {
+        "id": case.identity,
+        "channels": found.channels,
+        "unsupported": found.unsupported,
+        "columnTypes": found.column_types,
+    }
+
+
+def result_for(directory: str, envelope: Any) -> Dict[str, Any]:
+    """The plain invocation: the answer above, compared with the case's own files.
+
+    One of section 9's outcomes, with the first difference on a failure. A case
+    this engine cannot run is ``unsupported`` with the feature named, which
+    section 9 says is neither a pass nor a failure and is counted separately.
+    """
+    try:
+        case = read_case(directory)
+    except Malformed as reason:
+        return {"id": None, "outcome": "error", "reason": str(reason)}
+    answer = answer_for(directory, envelope)
+    if "error" in answer:
+        return {"id": answer["id"], "outcome": "error", "reason": answer["error"]}
+    if answer["unsupported"]:
+        return {
+            "id": answer["id"],
+            "outcome": "unsupported",
+            "feature": "; ".join(answer["unsupported"]),
+        }
+    tolerance, refused = tolerance_from(case.declared.get("tolerance"))
+    if tolerance is None:
+        return {"id": case.identity, "outcome": "error", "reason": f"case.json: {refused}"}
+    expected, missing = expected_channels(case, answer["columnTypes"])
+    if expected is None:
+        return {"id": case.identity, "outcome": "error", "reason": missing}
+    compared = compare_channels(case.asserts, answer["channels"], expected, tolerance)
+    return {"id": case.identity, **compared}
+
+
+def read_envelope(text: str) -> Any:
+    """The JSON object the invocation carried, or a refusal naming what arrived."""
+    try:
+        return json.loads(text) if text.strip() != "" else {}
+    except ValueError as reason:
+        raise Malformed(f"the invocation's standard input is not JSON: {reason}") from None
+
+
+def stdin_text() -> str:
+    """Everything the caller wrote, as text. Empty when nothing was piped in."""
+    if sys.stdin is None or sys.stdin.isatty():
+        return ""
+    return sys.stdin.read()
+
+
+def invoke(arguments: Any) -> Optional[Dict[str, Any]]:
+    """One of the three invocations, to the one object it writes, or nothing.
+
+    Nothing means the argument list is not one of the three, which
+    ``__main__.py`` refuses with a non-zero exit: no object it could write would
+    be a case result, and section 9 keeps a non-zero exit meaning a crash.
+    """
+    if list(arguments) == ["--describe"]:
+        return describe()
+    if len(arguments) == 2 and arguments[0] == "--actual":
+        return answer_for(arguments[1], read_envelope(stdin_text()))
+    if len(arguments) == 1 and not arguments[0].startswith("--"):
+        return result_for(arguments[0], read_envelope(stdin_text()))
+    return None

openscript/adapter/channels.py

@@ -0,0 +1,137 @@
+"""The three strategy channels, in the encoding ``conformance.md`` section 4 gives them.
+
+A channel of ``expected.json`` is "an ordered list, and each element is a flat
+object of named fields". ``orders`` is a ledger row of ``stdlib.md`` 17.7,
+``trades`` is a round trip, and ``performance`` is a list of one flat object
+holding the run's summary and nothing nested.
+
+**An intent is named by its ordinal and never by an id.** Section 3: "a case
+cannot know the id an engine minted and must not depend on its spelling". The
+ordinal counts every intent the run placed, so a bracket that appended no row
+still takes one, and the gaps in an ``orders`` channel are where the brackets
+were.
+
+**Nothing here computes.** Every figure is read off a row, a trade or a summary
+the layers next door folded, in the order they folded them, so a difference
+between two engines is a difference in the fold rather than in a projection.
+"""
+
+from typing import Any, Dict, List, Optional, Sequence
+
+from ..accounting import Summary, Trade
+from ..strategy import Intents, LedgerRow
+
+
+def order_row(row: LedgerRow, ordinal: int, qty_type: str) -> Dict[str, Any]:
+    """One ledger row, as a case records one.
+
+    The rejection is absence where there is none, because absence and the empty
+    string are different answers everywhere else in this language and a row a
+    destination said nothing about is not a row it rejected with no words.
+    """
+    return {
+        "intent": ordinal,
+        "orderRef": row.order_ref,
+        "tag": row.tag,
+        "leg": row.leg,
+        "positionRef": row.position_ref,
+        "symbol": row.instrument.symbol,
+        "exchange": row.instrument.exchange,
+        "product": row.product,
+        "side": row.side,
+        "qty": row.qty,
+        "qtyType": qty_type,
+        "type": row.order_type,
+        "price": row.price,
+        "trigger": row.trigger,
+        "status": row.status,
+        "filledQty": row.filled_qty,
+        "avgFillPrice": row.avg_fill_price,
+        "rejection": None if row.rejection == "" else row.rejection,
+        "placedAt": row.placed_at,
+        "updatedAt": row.updated_at,
+        "units": row.units,
+    }
+
+
+def orders_channel(rows: Sequence[LedgerRow], intents: Intents) -> List[Dict[str, Any]]:
+    """Every row of the ledger, oldest first, which is the order it was sent in."""
+    found: List[Dict[str, Any]] = []
+    for row in rows:
+        intent = intents.by_id(row.intent_id)
+        found.append(
+            order_row(
+                row,
+                intents.ordinal_of(row.intent_id),
+                "" if intent is None else intent.qty_type,
+            )
+        )
+    return found
+
+
+def trade_row(trade: Trade) -> Dict[str, Any]:
+    """One round trip, as a case records one."""
+    return {
+        "barsHeld": trade.bars_held,
+        "charges": trade.charges,
+        "closedAt": trade.closed_at,
+        "closedOnBar": trade.closed_on_bar,
+        "entries": trade.entries,
+        "entryPrice": trade.entry_price,
+        "exitPrice": trade.exit_price,
+        "exits": trade.exits,
+        "grossProfit": trade.gross_profit,
+        "index": trade.index,
+        "isOpen": trade.is_open,
+        "maxAdverse": trade.max_adverse,
+        "maxFavourable": trade.max_favourable,
+        "netProfit": trade.net_profit,
+        "openedAt": trade.opened_at,
+        "openedOnBar": trade.opened_on_bar,
+        "positionRef": trade.position_ref,
+        "side": trade.side,
+        "units": trade.units,
+    }
+
+
+def summary_row(summary: Summary) -> Dict[str, Any]:
+    """The run's summary, as a case records it: one flat object and nothing nested."""
+    return {
+        "averageBarsHeld": summary.average_bars_held,
+        "averageLoss": summary.average_loss,
+        "averageWin": summary.average_win,
+        "barCount": summary.bar_count,
+        "barsInMarket": summary.bars_in_market,
+        "capital": summary.capital,
+        "charges": summary.charges,
+        "currency": summary.currency,
+        "expectancy": summary.expectancy,
+        "expectancyStandardError": summary.expectancy_standard_error,
+        "grossLoss": summary.gross_loss,
+        "grossProfit": summary.gross_profit,
+        "longestDrawdownBars": summary.longest_drawdown_bars,
+        "losses": summary.losses,
+        "maxDrawdown": summary.max_drawdown,
+        "maxDrawdownAt": summary.max_drawdown_at,
+        "maxDrawdownPercent": summary.max_drawdown_percent,
+        "maxRunUp": summary.max_run_up,
+        "maxRunUpAt": summary.max_run_up_at,
+        "maxRunUpPercent": summary.max_run_up_percent,
+        "netProfit": summary.net_profit,
+        "openTradeCount": summary.open_trade_count,
+        "profitFactor": summary.profit_factor,
+        "returnPercent": summary.return_percent,
+        "scratches": summary.scratches,
+        "tradeCount": summary.trade_count,
+        "winRate": summary.win_rate,
+        "wins": summary.wins,
+    }
+
+
+def performance_channel(summary: Optional[Summary]) -> List[Dict[str, Any]]:
+    """The summary as the one element of an ordered list, which is what the channel is.
+
+    A list of one rather than an object, so that a reader and a runner need one
+    shape for every channel rather than two.
+    """
+    return [] if summary is None else [summary_row(summary)]