openscript 0.4.0__py3-none-any.whl

openscript/adapter/expectations.py

@@ -0,0 +1,67 @@
+"""What a case expects, read out of its own files into one mapping by channel.
+
+``conformance.md`` section 4 splits the expectation across two files for a reason
+it gives: ``expected.csv`` is one value per bar and one column per asserted
+channel, and ``expected.json`` is everything that is not, each channel an ordered
+list of flat objects. The comparison wants one shape, so both are read here into
+the shape the answer already has, and a channel the case asserts that neither
+file holds is a malformed case rather than a failure of the engine.
+
+**A cell is read as the channel's own type, and the case file does not carry
+one.** ``expected.csv`` has a header of column names and no types, so the four
+letters ``true`` in a string column and the bool are the same eight bytes on
+disk. The type comes from the compiled program's channel table
+(``compiled-program.md`` section 2.7), which the run has already resolved, and it
+is passed in here rather than guessed from the shape of the text: a guess would
+read a string channel that emitted ``true`` as a bool and report a difference
+that is in the reader rather than in either engine.
+"""
+
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple
+
+from .reading import Case
+from .spellings import Malformed, read_cell
+
+#: Section 4: the channel whose expectation is columnar, and the file it is in.
+COLUMNAR = "values"
+
+
+def values_expected(
+    columns: Sequence[str], rows: Sequence[Sequence[str]], types: Mapping[str, str]
+) -> list:
+    """``expected.csv`` as one flat object per bar, in the answer's own shape."""
+    out = []
+    for at, row in enumerate(rows):
+        held: Dict[str, Any] = {}
+        for which, name in enumerate(columns):
+            kind = types.get(name)
+            if kind is None:
+                raise Malformed(
+                    f"expected.csv names the column {name} and this program has no channel for it"
+                )
+            held[name] = read_cell(row[which], kind, f"expected.csv line {at + 2}, {name}")
+        out.append(held)
+    return out
+
+
+def expected_channels(
+    case: Case, types: Mapping[str, str]
+) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
+    """Every asserted channel as the case holds it, or the sentence refusing it."""
+    found: Dict[str, Any] = {}
+    for channel in case.asserts:
+        if channel == COLUMNAR:
+            if not case.expected_columns:
+                return None, "the case asserts values and holds no expected.csv (section 4)"
+            found[channel] = values_expected(case.expected_columns, case.expected_rows, types)
+            continue
+        if case.expected_json is None or channel not in case.expected_json:
+            return None, (
+                f"expected.json holds no {channel}, which case.json asserts. A case asserts the "
+                "channels it names, and one it names with nothing to compare against is malformed"
+            )
+        held = case.expected_json[channel]
+        if not isinstance(held, list):
+            return None, f"expected.json's {channel} is not an ordered list (section 4)"
+        found[channel] = held
+    return found, None

openscript/adapter/facts.py

@@ -0,0 +1,127 @@
+"""The two namespaces whose answer is the host's or the ledger's, not an argument's.
+
+``stdlib.md`` 3.4 is the ``chart`` namespace, 17.4 is the ``pos`` namespace and
+12.4 is the session's one derived entry. None of the three is in ``library/``,
+and that is the library's decision rather than an omission: every function there
+computes its answer from its arguments and its own region, and these read the
+instrument record the host stated, the fills this strategy settled and the
+boundary ``sessions.py`` derives. All of those arrive at this seam and nowhere
+else, so the manifest rows for them are here, beside the join that can answer
+them.
+
+**A fact nobody stated is absent**, which is ``host-interface.md`` 4.1's column
+for every entry but one: ``chart.symbol`` is the empty string, because 3.4 says
+so. A default anywhere else would make "the smallest increment is five paise"
+and "nobody said" the same reading.
+
+**The two derived facts are not here.** ``chart.intervalMinutes`` and
+``chart.isIntraday`` are computed from the interval string by section 15.2's
+canonical form, which this engine does not read yet, so a program calling one is
+refused at load by name (OS6004) rather than answered from a guess at what the
+string meant. The planned entries of both tables are absent for the same reason:
+a name the language does not serve yet is a refusal naming it.
+"""
+
+from typing import Any, Dict, Optional, Protocol, Tuple
+
+from ..values import ABSENT
+from .sessions import SESSION_FACTS
+
+#: Section 3.4 against ``host-interface.md`` 4.1: the call, and the fact of the
+#: instrument record it reads. Every one is arity 0, holds no state and has no
+#: effect, which is what the manifest check holds a program's own table to.
+CHART_FACTS: Dict[str, str] = {
+    "chart.symbol": "symbol",
+    "chart.exchange": "exchange",
+    "chart.interval": "interval",
+    "chart.timezone": "timezone",
+    "chart.tickSize": "tickSize",
+    "chart.lotSize": "lotSize",
+    "chart.pointValue": "pointValue",
+    "chart.currency": "currency",
+    "chart.instrumentType": "instrumentType",
+    "chart.hasVolume": "hasVolume",
+    "chart.hasOpenInterest": "hasOpenInterest",
+}
+
+#: The one entry of that table whose absent case is a value rather than absence.
+EMPTY_WHEN_UNSTATED: Tuple[str, ...] = ("chart.symbol",)
+
+#: Section 3.4: the clock, whose value a case fixes so that a script using it is
+#: still reproducible. It is the one entry of the namespace that is not a fact of
+#: the instrument.
+CHART_CLOCK = "chart.now"
+
+#: Section 17.4: the entries of the ``pos`` namespace that are not planned. Each
+#: is folded from this strategy's own fills and reflects fills rather than
+#: intentions, which is the position book's whole job.
+POSITION_FACTS: Tuple[str, ...] = (
+    "pos.size",
+    "pos.isLong",
+    "pos.isShort",
+    "pos.isFlat",
+    "pos.avgPrice",
+)
+
+
+class Book(Protocol):
+    """What a position fact is read from, and the whole of what it is asked.
+
+    The ledger answers it. Two methods rather than the ledger itself, so that
+    this module states what a reading of the ``pos`` namespace reaches: the
+    settled position and nothing about the orders that made it.
+    """
+
+    def size(self) -> float:
+        ...
+
+    def avg_price(self) -> Optional[float]:
+        ...
+
+
+def chart_value(name: str, instrument: Any, now: Any) -> Any:
+    """One ``chart`` entry, from the record the host stated and the fixed clock."""
+    if name == CHART_CLOCK:
+        return now
+    held = instrument.get(CHART_FACTS[name], ABSENT)
+    if held is ABSENT and name in EMPTY_WHEN_UNSTATED:
+        return ""
+    return held
+
+
+def position_value(name: str, book: Book) -> Any:
+    """One ``pos`` entry, from the ledger's own position book.
+
+    ``pos.size`` is ``0`` while flat rather than absent, because zero is the true
+    size and a script adding it to something should get the right answer.
+    ``pos.avgPrice`` is absent while flat rather than zero, because zero is a
+    price and a script comparing against it would take a branch that looks
+    correct. Section 17.4 states both, and the difference is the reason the two
+    are not one reading with a default.
+    """
+    if name == "pos.avgPrice":
+        return book.avg_price()
+    size = book.size()
+    if name == "pos.size":
+        return size
+    if name == "pos.isLong":
+        return size > 0
+    if name == "pos.isShort":
+        return size < 0
+    return size == 0
+
+
+#: Every name this module answers. The manifest rows built from it are all arity
+#: 0, hold no state and have no effect, which is what section 2.5's check holds a
+#: program's own library table to. The session's own entry is beside them because
+#: it is read the same way and answered from the bar rather than from a record.
+FACT_NAMES: Tuple[str, ...] = (*CHART_FACTS, CHART_CLOCK, *POSITION_FACTS, *SESSION_FACTS)
+
+
+def fact_value(name: str, instrument: Any, now: Any, book: Book, bar: Any) -> Any:
+    """Whichever of the three namespaces this name belongs to, read once."""
+    if name in POSITION_FACTS:
+        return position_value(name, book)
+    if name in SESSION_FACTS:
+        return bar
+    return chart_value(name, instrument, now)

openscript/adapter/matching.py

@@ -0,0 +1,257 @@
+"""The comparison of ``conformance.md`` section 6, in this language.
+
+The page prints the function and every step of it, and this is that function with
+nothing added. Each step is written out below beside the wrong implementation it
+refuses, because the whole value of the suite rests on this being the same rule
+in both engines: a comparison that was a little more forgiving in one of them
+would report agreement that is not there, which is worse than reporting none.
+
+1. Two absent values match, asked before anything numeric is.
+2. One absent and one present fail, whatever the tolerance. A number is not
+   nearly absent, and warmup length is a specified property, so a value one bar
+   early is a defect however small it is.
+3. A result that is not finite is its own outcome. ``language.md`` section 5.1
+   says an infinity and a not-a-number never appear as values, so producing one
+   is a defect rather than a near miss, and burying it among numeric failures
+   would hide the one failure that is never a rounding difference.
+4. Signed zero is normalised. Nothing in the language can observe the sign of a
+   zero, so comparing raw bits would fail a case over a difference no script can
+   see.
+5. Equality is over the eight bytes, not over a rendering, so a formatting
+   decision can never make two different values look equal.
+6. With both bounds zero, anything past step 5 fails.
+7. The bound is ``max(abs, rel * |e|)`` and never a sum: exactly one bound is in
+   force at any magnitude, and a failure can name which of the two it broke.
+
+**A declared tolerance is held to the caps section 6 prints.** A case past either
+is not a conformance case at all, and it is reported ``error`` rather than run
+under a bound the page refuses.
+"""
+
+import struct
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from .page import TOLERANCE_CAP_ABS, TOLERANCE_CAP_REL
+from .spellings import written
+
+#: Section 4: what a diagnostic is compared on, and nothing else. The message
+#: text and the suggested fix are deliberately not compared, because improving
+#: the wording of an error is something this project wants to keep doing.
+DIAGNOSTIC_FIELDS: Tuple[str, ...] = ("code", "line", "column", "severity")
+
+#: Section 6: exact, which is what a comparison is until a case declares otherwise.
+EXACT = (0.0, 0.0)
+
+_PASS: Dict[str, Any] = {"outcome": "pass"}
+
+
+def _bits(value: float) -> bytes:
+    """The eight bytes of a binary64, so equality is over bits and not over text."""
+    return struct.pack(">d", value)
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def compare_numbers(actual: Any, expected: Any, abs_bound: float, rel_bound: float) -> Dict[str, Any]:
+    """Steps 1 to 8, in the page's order, over one asserted numeric value."""
+    if expected is None and actual is None:
+        return _PASS
+    if expected is None or actual is None:
+        return {"outcome": "fail", "bound": "absence"}
+    if not _is_number(actual) or not _finite(actual):
+        return {"outcome": "nonFinite"}
+    if not _is_number(expected) or not _finite(expected):
+        return {"outcome": "nonFinite"}
+    left = 0.0 if actual == 0 else float(actual)
+    right = 0.0 if expected == 0 else float(expected)
+    if _bits(left) == _bits(right):
+        return _PASS
+    difference = abs(left - right)
+    if abs_bound == 0 and rel_bound == 0:
+        return {"outcome": "fail", "bound": "exact", "difference": difference}
+    relative = rel_bound * abs(right)
+    if difference <= max(abs_bound, relative):
+        return _PASS
+    return {
+        "outcome": "fail",
+        "bound": "abs" if abs_bound >= relative else "rel",
+        "difference": difference,
+    }
+
+
+def _finite(value: Any) -> bool:
+    return value == value and value not in (float("inf"), float("-inf"))
+
+
+def _kind_of(value: Any) -> str:
+    if value is None:
+        return "absent"
+    if isinstance(value, bool):
+        return "bool"
+    if _is_number(value):
+        return "number"
+    if isinstance(value, str):
+        return "string"
+    return "list" if isinstance(value, list) else "object"
+
+
+def compare_values(actual: Any, expected: Any, tolerance: Tuple[float, float]) -> Dict[str, Any]:
+    """One value of any kind, under section 6's table.
+
+    Absence is asked first for every kind, because the table says it is never
+    subject to a tolerance and that is as true of a string as of a number. Two
+    values of different kinds fail as ``kind``: a bool where a number was
+    expected is not a near miss.
+    """
+    if expected is None or actual is None:
+        return compare_numbers(actual, expected, tolerance[0], tolerance[1])
+    kind = _kind_of(expected)
+    if kind != _kind_of(actual):
+        return {"outcome": "fail", "bound": "kind"}
+    if kind == "number":
+        return compare_numbers(actual, expected, tolerance[0], tolerance[1])
+    if kind in ("bool", "string"):
+        return _PASS if actual == expected else {"outcome": "fail", "bound": "exact"}
+    return _PASS if _stable(actual) == _stable(expected) else {"outcome": "fail", "bound": "exact"}
+
+
+def _stable(value: Any) -> str:
+    """A nested value as one piece of text, keys sorted, so two spellings are one."""
+    if isinstance(value, list):
+        return "[" + ",".join(_stable(one) for one in value) + "]"
+    if isinstance(value, dict):
+        members = (f"{key}:{_stable(value[key])}" for key in sorted(value))
+        return "{" + ",".join(members) + "}"
+    return written(value)
+
+
+def _fields_of(channel: str, expected: Dict[str, Any]) -> Sequence[str]:
+    """Section 4: four fields for a diagnostic, else the expected element's own.
+
+    "Compared on the fields the case names and no others" is what lets a case
+    assert the part of a ledger row it is about without freezing every other
+    field of it.
+    """
+    if channel == "diagnostics":
+        return DIAGNOSTIC_FIELDS
+    return sorted(expected)
+
+
+def _difference(
+    result: Dict[str, Any],
+    channel: str,
+    index: Optional[int],
+    column: Optional[str],
+    actual: Any,
+    expected: Any,
+) -> Dict[str, Any]:
+    found = {
+        "outcome": result["outcome"],
+        "channel": channel,
+        "index": index,
+        "column": column,
+        "expected": written(expected),
+        "actual": written(actual),
+    }
+    if "bound" in result:
+        found["bound"] = result["bound"]
+    if "difference" in result:
+        found["difference"] = written(result["difference"])
+    return found
+
+
+def compare_channel(
+    channel: str, actual: Any, expected: Any, tolerance: Tuple[float, float]
+) -> Optional[Dict[str, Any]]:
+    """One channel: an ordered list, length first, then element by element.
+
+    Nothing when the channel matches, else the first difference with its index,
+    its column and both values as a report writes them. A length mismatch is
+    reported before any element is compared, which is section 6's table, and at
+    the first index one list has and the other lacks.
+    """
+    if not isinstance(expected, list) or not isinstance(actual, list):
+        return {
+            "outcome": "fail",
+            "channel": channel,
+            "index": None,
+            "column": None,
+            "bound": "kind",
+            "expected": _kind_of(expected),
+            "actual": _kind_of(actual),
+        }
+    if len(actual) != len(expected):
+        return {
+            "outcome": "fail",
+            "channel": channel,
+            "index": min(len(actual), len(expected)),
+            "column": None,
+            "bound": "length",
+            "expected": str(len(expected)),
+            "actual": str(len(actual)),
+        }
+    for index, want in enumerate(expected):
+        got = actual[index]
+        if not isinstance(want, dict):
+            result = compare_values(got, want, tolerance)
+            if result["outcome"] != "pass":
+                return _difference(result, channel, index, None, got, want)
+            continue
+        for column in _fields_of(channel, want):
+            wanted = want.get(column)
+            found = got.get(column) if isinstance(got, dict) else None
+            result = compare_values(found, wanted, tolerance)
+            if result["outcome"] != "pass":
+                return _difference(result, channel, index, column, found, wanted)
+    return None
+
+
+def compare_channels(
+    asserted: Sequence[str],
+    actual: Dict[str, Any],
+    expected: Dict[str, Any],
+    tolerance: Tuple[float, float],
+) -> Dict[str, Any]:
+    """Every asserted channel, in the case's own order, to one outcome."""
+    for channel in asserted:
+        found = compare_channel(channel, actual.get(channel), expected.get(channel), tolerance)
+        if found is not None:
+            return found
+    return dict(_PASS)
+
+
+def tolerance_from(declared: Any) -> Tuple[Optional[Tuple[float, float]], Optional[str]]:
+    """The case's tolerance, held to section 6, or the sentence refusing it.
+
+    Absent means exact. A non-zero bound needs a stated reason, which is the rule
+    that stops a tolerance from being the thing an engine author widens until the
+    suite goes green. A bound past the cap is not a conformance case at all.
+    """
+    if declared is None:
+        return EXACT, None
+    if not isinstance(declared, dict):
+        return None, "tolerance is not an object"
+    bounds: List[float] = []
+    for name in ("abs", "rel"):
+        value = declared.get(name, 0)
+        if value is None:
+            value = 0
+        if not _is_number(value) or not _finite(value):
+            return None, f"tolerance.{name} is not a finite number"
+        if value < 0:
+            return None, f"tolerance.{name} is below zero"
+        bounds.append(float(value))
+    abs_bound, rel_bound = bounds[0], bounds[1]
+    reason = declared.get("reason")
+    stated = isinstance(reason, str) and reason.strip() != ""
+    if (abs_bound != 0 or rel_bound != 0) and not stated:
+        return None, "a non-zero tolerance is declared with no reason (section 6)"
+    if abs_bound > TOLERANCE_CAP_ABS or rel_bound > TOLERANCE_CAP_REL:
+        return None, (
+            f"a tolerance of abs {written(abs_bound)} and rel {written(rel_bound)} is looser than "
+            f"the cap of abs {written(TOLERANCE_CAP_ABS)} and rel {written(TOLERANCE_CAP_REL)}, so "
+            "this is not a conformance case (section 6)"
+        )
+    return (abs_bound, rel_bound), None

openscript/adapter/ordering.py

@@ -0,0 +1,187 @@
+"""The nine order calls as this engine's manifest holds them, and the desk behind them.
+
+``stdlib.md`` 17.2 and 17.3 are the calls, ``host-interface.md`` 7.2 and 7.4 are
+the frames and the boundary they fold at, and ``strategy/`` is all of the
+behaviour. What is here is the join: the manifest rows a program's own library
+table is checked against, and the object that carries a ledger, its intents and
+its fills through one case.
+
+**An order call is an effect and is not performed when it executes.**
+``compiled-program.md`` 5.4 has a function with an effect leave a record and push
+absence, and step 9 applies the record only on a bar the engine decided. So the
+machine hands this desk the calls a decided bar left behind, in the order the bar
+made them, and a condition that was true halfway through a moving bar and false
+when it closed places no order at all.
+
+**A frame is delivered after a bar and folded before the next one.**
+``conformance.md`` section 3 says ``afterBar`` is "the index of the bar after
+whose execution the frame is delivered, so the fold happens at a bar boundary
+before the next execution". Read as it is written, a frame naming the last bar is
+delivered and never folded, because there is no next execution to fold before.
+That is a hole in the page rather than a decision to make here, so such a case is
+named ``unsupported`` by the caller rather than answered under one reading of
+two.
+
+**A refusal takes back the whole bar.** ``Ledger.discard`` is what that costs, and
+the reason is in its own docstring: every call of a bar is mapped before any of
+them is routed, so a refusal after one has appended a row would otherwise leave a
+row no destination was ever handed.
+"""
+
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+from ..contracts import LibraryEntry
+from ..diagnostics import Diagnostic
+from ..strategy import (
+    Fills,
+    Identity,
+    IntentBar,
+    Intents,
+    Ledger,
+    LedgerOptions,
+    LedgerRow,
+    OrderFrame,
+)
+from ..strategy.calls import PARAMETERS
+from .reading import Frame
+
+#: Section 2.5's row for each of the nine, by name and argument count. The count
+#: is one more than the signature's, which is ``compiled-program.md`` 4.10's
+#: extra argument: the names of the arguments the script wrote. None of them
+#: holds state, and every one of them has the ``order`` effect, which is what
+#: makes the machine hold the call until step 9 rather than calling into here.
+ORDER_ENTRIES: Dict[Tuple[str, int], LibraryEntry] = {
+    (name, len(parameters) + 1): LibraryEntry(name, len(parameters) + 1, False, "order")
+    for name, parameters in PARAMETERS.items()
+}
+
+
+class Desk:
+    """One strategy's ledger, its intents and its fills, driven over one case.
+
+    The caller owns the bar loop, because the bars are the case's and the
+    execution is the machine's. What is owned here is the order of the three
+    things that happen between two executions, and that order is
+    ``host-interface.md`` 7.4's rather than this class's choice.
+    """
+
+    def __init__(self, frames: Sequence[Frame] = ()) -> None:
+        self.ledger = Ledger()
+        self.intents = Intents()
+        self.fills = Fills()
+        #: The destination's own reference per intent, recorded at delivery, so
+        #: that a fill carries the reference the frame that made it carried.
+        self._refs: Dict[int, str] = {}
+        self._after: Dict[int, List[Frame]] = {}
+        for frame in frames:
+            self._after.setdefault(frame.after_bar, []).append(frame)
+        self._waiting: Tuple[Frame, ...] = ()
+
+    def begin(self, options: LedgerOptions) -> None:
+        """The declaration's own settings, before bar 0 and after the load.
+
+        A ledger exists before the program is loaded, because the manifest has to
+        answer whether this engine holds ``pos.size`` before anything has read a
+        declaration, and the declaration's settings can only be read once the
+        inputs behind them are resolved, which is what a load does. Nothing has
+        placed an order in between: the first bar is what places one.
+        """
+        self.ledger.options = options
+
+    # -- the boundary between two bars --------------------------------------
+
+    def fold(self, index: int, time: Optional[float]) -> None:
+        """Deliver what the destination sent after the last bar, then fold it.
+
+        Delivered first and folded second, in one call, because the two are one
+        boundary: a driver that folded before delivering would hold every frame
+        for a bar longer, and a script would read a position one bar late.
+        """
+        for frame in self._waiting:
+            named = self.intents.at_ordinal(frame.intent)
+            if named is not None and frame.order_ref != "":
+                self._refs[named.intent_id] = frame.order_ref
+            self.ledger.deliver(
+                OrderFrame(
+                    # An ordinal naming no intent this run placed is how a case
+                    # hands an engine a frame about an order its ledger does not
+                    # hold. Step 1 of the fold refuses it, which is the ledger's
+                    # to do and not this driver's, so an id no run can mint goes
+                    # over rather than the frame being dropped here.
+                    intent_id=-1 if named is None else named.intent_id,
+                    status=frame.status,
+                    filled_qty=frame.filled_qty,
+                    avg_fill_price=frame.avg_fill_price,
+                    order_ref=frame.order_ref,
+                    text=frame.text,
+                    # When the destination answered. Left off, every frame
+                    # carried the instant of the bar that placed the order, so a
+                    # case whose destination answered later was answered one way
+                    # here and another by the first engine, at `updatedAt` and
+                    # at nothing else.
+                    time=frame.time,
+                )
+            )
+        self._waiting = ()
+        self.fills.record(self.ledger.settle(), self.intents, index, time, self._refs)
+
+    def deliver_after(self, index: int) -> None:
+        """The frames this case says the destination sent after bar ``index``."""
+        self._waiting = tuple(self._after.get(index, ()))
+
+    # -- what a decided bar sent --------------------------------------------
+
+    def apply(self, effects: Iterable[Any], bar: IntentBar) -> Optional[Diagnostic]:
+        """Step 9's order calls, in the order the bar made them, or the refusal.
+
+        Every effect a program of this engine's can leave is one of the nine,
+        because they are the only entries in its manifest with an effect at all,
+        so the name goes to the ledger rather than being sorted here.
+        """
+        appended = len(self.ledger.rows())
+        for effect in effects:
+            placed = self.ledger.place(effect.name, effect.arguments, bar, effect.position)
+            if placed.refusal is not None:
+                self.ledger.discard(appended)
+                return placed.refusal
+            self.intents.record(placed.intents)
+        return None
+
+    # -- what a script and a report read ------------------------------------
+
+    def size(self) -> float:
+        return self.ledger.size()
+
+    def avg_price(self) -> Optional[float]:
+        return self.ledger.avg_price()
+
+    def rows(self) -> Sequence[LedgerRow]:
+        return self.ledger.rows()
+
+
+def unfoldable(frames: Sequence[Frame], bars: int) -> Tuple[Frame, ...]:
+    """The frames of a case that no boundary folds, which is the hole above.
+
+    A frame named after the last bar is delivered and never folded, so a case
+    carrying one is answered ``unsupported`` naming it rather than run to a
+    ledger that is missing whatever it said.
+    """
+    return tuple(frame for frame in frames if frame.after_bar >= bars - 1)
+
+
+def options_for(declared: Dict[str, Any], instrument: Dict[str, Any]) -> LedgerOptions:
+    """What the declaration and the instrument record fix before bar 0.
+
+    ``declared`` is the strategy block of the compiled program's meta, with every
+    input reference already resolved: a script may declare its own quantity from
+    an input, and a ledger handed the reference rather than the value would size
+    every order from a shape.
+    """
+    return LedgerOptions(
+        instrument=Identity(instrument.get("symbol"), instrument.get("exchange")),
+        product=declared["product"],
+        qty_type=declared["qtyType"],
+        declared_qty=declared["qty"],
+        tick_size=instrument.get("tickSize"),
+        pyramiding=declared["pyramiding"],
+    )