openscript 0.4.0__py3-none-any.whl

openscript/diagnostics.py

@@ -0,0 +1,104 @@
+"""How this engine says something went wrong, and what it refuses to say twice.
+
+Every failure carries a catalogue code, a position and the values the
+catalogue's message has placeholders for. Nothing here holds the message text.
+That is deliberate and it is the repository's own rule read in this language:
+`spec/errors.json` is the catalogue and the authority, the wording is generated
+into the first engine rather than retyped in it, and a second engine that typed
+the sentences out again would be a second place for them to be wrong. A host
+that wants the prose has the catalogue; what the conformance suite compares is
+the code, the line, the column and the severity, and those are all here.
+
+The placeholder names are held to the catalogue by a test rather than by
+attention: a name this engine invents is a message with a hole in it, and the
+hole would only ever be seen by the user it was written for.
+
+**Severity is derived and not copied.** An engine's failure stops something: a
+bar, or a load. There is no reading of a compiled program that produces a
+warning, because nothing downstream of the engine could act on one, so every
+diagnostic raised from here is an error and the constant below says so once. The
+same test measures that against the catalogue.
+
+**A failure is thrown rather than returned.** An error in the middle of an
+expression has to abandon the rest of the bar, and there is no value a division
+by zero could return that every instruction above it would not have to check
+again. The throw crosses the interpreter and stops at the one boundary that
+knows what to do with it, and nothing this package exposes lets it out: a host
+draws many studies in one loop, and one script failing has to be a diagnostic
+about that script and nothing else.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping, NamedTuple
+
+
+class Position(NamedTuple):
+    """Where a diagnostic points, as ``debug.pos`` holds it: a line and a column.
+
+    A compiled program carries a position per instruction and not an offset into
+    text, because the engine is handed a program and not the source it came
+    from. Line and column still say where, which is what a message needs.
+    """
+
+    line: int
+    column: int
+
+
+#: What a load-time failure carries. The defect is in the program rather than in
+#: the source, so there is no line to name: ``compiled-program.md`` section 10.
+NO_POSITION = Position(0, 0)
+
+#: The one severity an engine raises. See the note at the head of this module.
+ERROR = "error"
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    """One failure: a code, where it happened, and the message's own values."""
+
+    code: str
+    position: Position
+    values: Mapping[str, Any] = field(default_factory=dict)
+    severity: str = ERROR
+
+    @property
+    def line(self) -> int:
+        return self.position.line
+
+    @property
+    def column(self) -> int:
+        return self.position.column
+
+
+class ScriptError(Exception):
+    """A diagnostic on its way out of the machine."""
+
+    def __init__(self, diagnostic: Diagnostic) -> None:
+        super().__init__(diagnostic.code)
+        self.diagnostic = diagnostic
+
+
+def failure(code: str, position: Position = NO_POSITION, **values: Any) -> Diagnostic:
+    """The diagnostic for a code, with the values its message names."""
+    return Diagnostic(code=code, position=position, values=dict(values))
+
+
+def raise_at(code: str, position: Position = NO_POSITION, **values: Any) -> Any:
+    """Throw that diagnostic. Returns nothing: the call never comes back."""
+    raise ScriptError(failure(code, position, **values))
+
+
+def malformed(location: str, reason: str) -> Diagnostic:
+    """A verification failure, ``compiled-program.md`` section 3.5.
+
+    One code covers a malformed instruction list, an unreadable encoding and a
+    reference naming an input that was never declared, because they are not
+    three fixes: all three are defects of the compiler that wrote the program
+    and none of them is repairable by hand.
+    """
+    return failure("OS6018", NO_POSITION, location=location, reason=reason)
+
+
+def at_instruction(listing: str, index: int) -> str:
+    """The location half of OS6018 for an instruction, spelled as 3.5 spells it."""
+    return f"instruction {index}" if listing == "code" else f"{listing} instruction {index}"

openscript/hours.py

@@ -0,0 +1,165 @@
+"""A range of wall clock hours, and where one reading sits inside it.
+
+Two different things in this repository are a range of hours: the instrument's
+own trading session, which a host states in its instrument record
+(`host-interface.md` 4.3), and the range a script writes for ``session.isIn``
+(`stdlib.md` 12.5). They are spelled differently and they mean different things,
+and the arithmetic under them is one arithmetic, so it is here rather than in
+each of them. A second copy would be a fact stated twice, and the two copies
+would not drift over anything a reader could see: they would drift over midnight,
+or over which day a list of days is read against, on the one dataset nobody
+tests.
+
+**The open is inclusive and the close is exclusive**, so two ranges written back
+to back cover every minute once and no minute twice. A range whose start and end
+are the same minute holds nothing, which is what writing a zero length range
+says.
+
+**A range whose end is before its start crosses midnight and is read that way**,
+which is what an overnight session needs (4.3, and 12.5 for the script's own
+spelling). The day list then names the day the range opened on rather than the
+day the reading falls on, because a session that opens on Friday evening and
+closes on Saturday morning is a Friday session: reading the list against the
+reading's own day would drop half of every overnight session and keep the wrong
+half.
+
+**A session is named by the day it opened on**, which is what tells two readings
+in one session from two readings in two. Naming it by an instant would be wrong
+across a seasonal clock change, where a wall clock hour inside a session is not
+an hour of elapsed time.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Optional, Sequence, Tuple
+
+from .civil import Civil, DAY_MINUTES, day_number, minutes_of, weekday_of_day
+
+#: 4.3: midnight at the end of the day, which is the one spelling past 23:59.
+END_OF_DAY = DAY_MINUTES
+
+#: ``"HH:MM"``, the one spelling 4.3 fixes for a bound of the record's session.
+_CLOCK = re.compile(r"^([0-9]{2}):([0-9]{2})$")
+
+#: 12.5: ``"HHMM-HHMM"`` with an optional colon and a run of day digits.
+_WINDOW = re.compile(r"^([0-9]{2})([0-9]{2})-([0-9]{2})([0-9]{2})(?::([1-7]{1,7}))?$")
+
+
+@dataclass(frozen=True)
+class Hours:
+    """Hours as minutes from midnight, and the days they open on."""
+
+    start: int
+    #: Minutes from midnight at the close, which may be at 24:00.
+    end: int
+    #: The days it opens on, Monday as 1, or nothing for every day.
+    days: Optional[Tuple[int, ...]] = None
+
+    @property
+    def crosses_midnight(self) -> bool:
+        """4.3: "an ``end`` earlier than its ``start`` crosses midnight"."""
+        return self.end < self.start
+
+
+@dataclass(frozen=True)
+class Standing:
+    """Where one reading sits in a range of hours."""
+
+    inside: bool
+    #: Minutes since the hours opened, zero on the minute they opened.
+    elapsed: float = 0.0
+    #: Minutes until they are scheduled to close.
+    remaining: float = 0.0
+    #: The day they opened on, which is the name of this one session.
+    opening_day: int = 0
+
+
+OUTSIDE = Standing(False)
+
+
+def clock_minutes(text: object) -> Optional[int]:
+    """``"HH:MM"`` as minutes from midnight, or nothing for another spelling.
+
+    ``"9:00"`` is the spelling a host writes first and it is not a time here, so
+    it has no reading rather than a generous one: a record stating a window in a
+    spelling the page does not have is a record whose author believes they stated
+    a session, and 4.3 refuses it instead of reading it.
+    """
+    if not isinstance(text, str):
+        return None
+    found = _CLOCK.match(text)
+    if found is None:
+        return None
+    hour, minute = int(found.group(1)), int(found.group(2))
+    if hour > 24 or minute > 59 or (hour == 24 and minute != 0):
+        return None
+    return hour * 60 + minute
+
+
+def window_of(spec: object) -> Optional[Hours]:
+    """The hours a ``session.isIn`` spec names, or nothing where it is malformed.
+
+    12.5's grammar, and the bounds it allows: ``"2400"`` is midnight at the end
+    of the day and is the one hour past 23 a spec may write. A malformed spec is
+    OS3008 at compile time when it is a literal, and absence here when it is not:
+    the alternative would stop a chart on a string the script built on one bar
+    out of forty thousand, and absence is a value a script can test.
+    """
+    if not isinstance(spec, str):
+        return None
+    found = _WINDOW.match(spec)
+    if found is None:
+        return None
+    from_hour, from_minute = int(found.group(1)), int(found.group(2))
+    to_hour, to_minute = int(found.group(3)), int(found.group(4))
+    if from_hour > 23 or from_minute > 59 or to_minute > 59:
+        return None
+    if to_hour > 24 or (to_hour == 24 and to_minute != 0):
+        return None
+    listed = found.group(5)
+    days = None if listed is None else tuple(int(one) for one in listed)
+    return Hours(from_hour * 60 + from_minute, to_hour * 60 + to_minute, days)
+
+
+def standing_in(hours: Hours, at: Civil) -> Standing:
+    """Where a wall clock reading sits in a range of hours, or outside every one."""
+    minutes = minutes_of(at)
+    today = day_number(at.year, at.month, at.day)
+
+    if hours.end > hours.start:
+        if minutes < hours.start or minutes >= hours.end:
+            return OUTSIDE
+        return _held(hours, today, minutes - hours.start, hours.end - minutes)
+    if hours.end == hours.start:
+        return OUTSIDE
+
+    # Crossing midnight: the evening part belongs to today's session and the
+    # morning part to yesterday's, which is the day the list is read against.
+    if minutes >= hours.start:
+        return _held(hours, today, minutes - hours.start, DAY_MINUTES - minutes + hours.end)
+    if minutes < hours.end:
+        return _held(
+            hours, today - 1, DAY_MINUTES - hours.start + minutes, hours.end - minutes
+        )
+    return OUTSIDE
+
+
+def _held(hours: Hours, opening_day: int, elapsed: float, remaining: float) -> Standing:
+    """One reading inside the hours, unless the day it opened on is not one of theirs."""
+    if hours.days is not None and weekday_of_day(opening_day) not in hours.days:
+        return OUTSIDE
+    return Standing(True, elapsed, remaining, opening_day)
+
+
+def days_numbered(days: Sequence[object]) -> bool:
+    """Whether a stated day list is the numbering ``date.dayOfWeek`` uses.
+
+    Monday is 1 through Sunday is 7, and an empty list is not a list of days: a
+    host numbering Sunday as 0 states a week the instrument never opens in, which
+    4.3 refuses rather than reads.
+    """
+    if not days:
+        return False
+    return all(
+        isinstance(day, int) and not isinstance(day, bool) and 1 <= day <= 7 for day in days
+    )

openscript/inputs.py

@@ -0,0 +1,239 @@
+"""Inputs, resolved once at load, sections 2.6 and 5.1.
+
+Input resolution and the substitution of every ``{ "input": ... }`` reference
+happen **once, before step 1 of bar 0**, so the declarations in ``outputs`` and
+anything built from them exist before the first bar runs. Step 5 writes already
+resolved values into slots and resolves nothing.
+
+**A value that fails validation is a refusal, not a fallback.** The host's value
+is used when it passes and the declared default when the host supplies none, and
+a supplied value that fails is OS6019 and the program does not run. Falling back
+to the default would be a settings dialog that silently ignores what a user
+typed, which is worse than one that says the value is out of range.
+
+**An input value is never absent.** ``input()`` cannot declare ``none`` as a
+default, because the default's type is what fixes the input's type.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple
+
+from .bars import is_bar_field
+from .diagnostics import Diagnostic, failure
+from .program import constant_value
+from .values import ABSENT, Colour, is_number
+
+#: The eight built-in series a ``"source"`` input may select, section 2.6.
+SOURCES: Tuple[str, ...] = (
+    "open",
+    "high",
+    "low",
+    "close",
+    "hl2",
+    "hlc3",
+    "ohlc4",
+    "volume",
+)
+
+
+@dataclass(frozen=True)
+class ResolvedInput:
+    key: str
+    slot: int
+    #: The bar field a ``"source"`` input selected, which step 5 reads per bar.
+    field: Optional[str]
+    #: The effective value, for every other kind.
+    value: Any
+
+
+@dataclass(frozen=True)
+class InputResult:
+    inputs: Sequence[ResolvedInput]
+    diagnostic: Optional[Diagnostic] = None
+
+    @property
+    def ok(self) -> bool:
+        return self.diagnostic is None
+
+
+TimeReader = Callable[[str], Optional[float]]
+
+
+def resolve_inputs(
+    raw: Mapping[str, Any],
+    settings: Mapping[str, Any],
+    read_time: Optional[TimeReader] = None,
+) -> InputResult:
+    found: List[ResolvedInput] = []
+    for declared in raw["inputs"]:
+        one, refusal = _resolve_one(declared, settings, read_time)
+        if refusal is not None:
+            return InputResult((), refusal)
+        found.append(one)
+    return InputResult(tuple(found))
+
+
+def _resolve_one(
+    declared: Mapping[str, Any],
+    settings: Mapping[str, Any],
+    read_time: Optional[TimeReader],
+) -> Tuple[Optional[ResolvedInput], Optional[Diagnostic]]:
+    supplied = settings[declared["key"]] if declared["key"] in settings else None
+    fallback = constant_value(declared["default"])
+
+    # A source and a time are checked even where the host stored nothing,
+    # because each declares its value as text this engine still has to read.
+    # Every other kind takes its declared default unexamined: a default is
+    # written in the source, and validation here is about a value that arrived
+    # from outside it.
+    ask_anyway = declared["kind"] in ("source", "time")
+    if declared["key"] not in settings and not ask_anyway:
+        return ResolvedInput(declared["key"], declared["slot"], None, fallback), None
+
+    held = fallback if declared["key"] not in settings else supplied
+    value, field, refusal = check_setting(declared, held, read_time)
+    if refusal is not None:
+        return None, failure(
+            "OS6019", value=_describe(held), key=declared["key"], validation=refusal
+        )
+    return ResolvedInput(declared["key"], declared["slot"], field, value), None
+
+
+def check_setting(
+    declared: Mapping[str, Any],
+    supplied: Any,
+    read_time: Optional[TimeReader] = None,
+) -> Tuple[Any, Optional[str], Optional[str]]:
+    """What the engine will run with for one stored value, or the rule it breaks.
+
+    Answered outside the engine as well: a chart builds a settings dialog before
+    anything is loaded, so it has to know what a stored value is worth before the
+    run that would refuse it exists. A second copy of these rules in an adapter
+    would be the same fact in two files, answering differently the first time
+    either was edited.
+    """
+    kind = declared["kind"]
+    if kind == "source":
+        if not isinstance(supplied, str) or supplied not in SOURCES:
+            return None, None, f"a source names one of {', '.join(SOURCES)}"
+        if not is_bar_field(supplied):
+            return None, None, "this engine has no bar field of that name"
+        return ABSENT, supplied, None
+
+    if kind == "time":
+        unreadable = "a time is a timestamp or a date and time the host can read"
+        if is_number(supplied):
+            return float(supplied), None, None
+        if not isinstance(supplied, str):
+            return None, None, unreadable
+        if read_time is None:
+            return supplied, None, None
+        when = read_time(supplied)
+        if when is None:
+            return None, None, unreadable
+        return float(when), None, None
+
+    broken = _validate(declared, supplied)
+    if broken is not None:
+        return None, None, broken
+    return _as_value(supplied), None, None
+
+
+def _as_value(supplied: Any) -> Any:
+    """A stored setting as a machine value: a number is a float, a colour a colour."""
+    if isinstance(supplied, bool) or isinstance(supplied, str) or supplied is None:
+        return supplied if supplied is not None else ABSENT
+    if is_number(supplied):
+        return float(supplied)
+    if isinstance(supplied, Colour):
+        return supplied
+    if isinstance(supplied, (list, tuple)) and len(supplied) == 4:
+        red, green, blue, alpha = supplied
+        return Colour(float(red), float(green), float(blue), float(alpha))
+    return supplied
+
+
+def _validate(declared: Mapping[str, Any], supplied: Any) -> Optional[str]:
+    """What rule the host's value broke, or nothing when it passes."""
+    kind = declared["kind"]
+    if kind == "number":
+        if not is_number(supplied):
+            return "this input takes a number"
+        if declared.get("min") is not None and supplied < declared["min"]:
+            return f"the minimum is {declared['min']}"
+        if declared.get("max") is not None and supplied > declared["max"]:
+            return f"the maximum is {declared['max']}"
+        return None
+    if kind == "bool":
+        return None if isinstance(supplied, bool) else "this input takes true or false"
+    if kind == "color":
+        return None if _is_colour(supplied) else "this input takes a colour"
+    if kind == "select":
+        if not isinstance(supplied, str):
+            return "this input takes one of its listed values"
+        allowed = [constant_value(one) for one in (declared.get("options") or [])]
+        if supplied not in allowed:
+            return f"the choices are {', '.join(str(one) for one in allowed)}"
+        return None
+    return None if isinstance(supplied, str) else "this input takes a string"
+
+
+def _is_colour(value: Any) -> bool:
+    if isinstance(value, Colour):
+        return True
+    return isinstance(value, (list, tuple)) and len(value) == 4 and all(
+        is_number(one) for one in value
+    )
+
+
+def field_value(field: Any, inputs: Sequence[ResolvedInput]) -> Any:
+    """A declaration field with its ``{ "input": key }`` reference substituted.
+
+    Every field of ``meta``, of ``meta.strategy`` and of every declaration in
+    ``outputs`` may hold the reference, and it is gone before bar 0.
+    """
+    if field is None:
+        return ABSENT
+    if isinstance(field, dict):
+        key = field.get("input")
+        for one in inputs:
+            if one.key == key:
+                return one.value
+        return ABSENT
+    if isinstance(field, (list, tuple)) and len(field) == 4 and all(is_number(one) for one in field):
+        red, green, blue, alpha = field
+        return Colour(float(red), float(green), float(blue), float(alpha))
+    return field
+
+
+#: A date and time read as if it were UTC.
+#:
+#: **A stand-in.** ``stdlib.md`` section 12.1 reads every calendar field in the
+#: chart's timezone, which is an IANA name the host states, and an engine that
+#: has not been given one cannot apply it. A host with a zone supplies its own
+#: reader; this is what a test and a host with no zone get, and it is
+#: deterministic, which is the property that matters most here.
+def utc_time(text: str) -> Optional[float]:
+    for pattern in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M",
+                    "%Y-%m-%dT%H:%M", "%Y-%m-%d"):
+        try:
+            when = datetime.strptime(text.strip(), pattern)
+        except ValueError:
+            continue
+        return when.replace(tzinfo=timezone.utc).timestamp() * 1000
+    return None
+
+
+def _describe(value: Any) -> str:
+    if value is None:
+        return "none"
+    if isinstance(value, str):
+        return f'"{value}"'
+    if isinstance(value, bool) or is_number(value):
+        return str(value)
+    return "a value of another type"
+
+
+def settings_slots(inputs: Sequence[ResolvedInput]) -> Dict[int, ResolvedInput]:
+    return {one.slot: one for one in inputs}

openscript/intervals.py

@@ -0,0 +1,60 @@
+"""Timeframe strings, and the one thing the session facts need from them.
+
+`stdlib.md` section 15.2 fixes the spelling: a count and a unit, with the unit
+letters case sensitive so ``"1M"`` is one month and ``"1m"`` one minute, and a
+bare number read as minutes because that is the form an interval input supplies.
+`host-interface.md` 4.1 states the instrument's own interval in that spelling and
+calls two facts derived from it, which is why an engine reads the string rather
+than being told the number: two sources for one fact can disagree and no rule
+would say which of them wins.
+
+**What is here is the length of one bar and nothing else.** Folding a coarser
+timeframe onto a chart's bars is section 15's work and another stage's; the
+session facts need one number, the minutes a bar covers, and they need it for one
+reason, which is the fact `host-interface.md` 4.3 says earns the session its
+place: ``session.isLastBar`` is true on the last bar of the schedule even when
+trading stopped early, and the bar that reaches the scheduled close is a bar slot
+measured against it. Without the interval there is no slot, and an engine that
+answered from the next bar's time would be making a reading no live engine can
+make: on the bar in front of you there is no next bar.
+
+**A month is counted at its nominal length**, thirty days, and that is not a
+claim about a calendar. Any bar of a day or more spans a whole session whatever
+the exact figure, so every number past the length of a session gives the session
+facts the same answer. Where a calendar bucket actually begins is a different
+question, and a stage that folds one answers it from the calendar rather than
+from this.
+
+**A string this grammar does not hold leaves the answer absent.** A host that
+states an interval in a spelling 15.2 does not have has stated nothing this
+engine can read, and the session facts that depend on it are absent rather than
+answered from a guess at what the string meant.
+"""
+
+import re
+from typing import Optional
+
+#: 15.2's grammar. A bare number is minutes, which is the interval form a host
+#: supplies, and the letters are case sensitive.
+_WRITTEN = re.compile(r"^([0-9]+)(m|h|D|W|M)?$")
+
+#: The nominal length of one unit in minutes, which is what orders two
+#: timeframes and what sizes a bar slot.
+_NOMINAL = {"m": 1, "h": 60, "D": 1440, "W": 10080, "M": 43200}
+
+
+def bar_minutes_of(interval: object) -> Optional[float]:
+    """Minutes one bar of this interval covers, or nothing for a string 15.2 has not.
+
+    A count of zero is not an interval: a bar of no length would make every bar
+    the last of its session, which is the one reading worse than absence.
+    """
+    if not isinstance(interval, str):
+        return None
+    found = _WRITTEN.match(interval.strip())
+    if found is None:
+        return None
+    count = int(found.group(1))
+    if count < 1:
+        return None
+    return float(count * _NOMINAL[found.group(2) or "m"])

openscript/library/__init__.py

@@ -0,0 +1,76 @@
+"""The library of `spec/stdlib.md`, in the accumulation order section 20 fixes.
+
+This door exports **both halves**, as two tables rather than one. The stateless
+half is every function whose result depends on this bar's arguments and this
+bar's facts and on nothing it remembers; the stateful half is the averages and
+the windowed studies that carry a state region from bar to bar. They are two
+tables because a call of one takes two things and a call of the other takes
+three: the region is the difference, and a single table would hand a caller two
+shapes to tell apart at the call site rather than at the manifest.
+
+What is here, by the page it is written from:
+
+- ``values``        absence, and the two rules every number returned has passed
+- ``arithmetic``    section 8.1, the bare calls that compute one value
+- ``rounding``      section 8.1 and 20.7, one rule for halves and one scale table
+- ``elementary``    section 8.2, the square root and the gap 1 family
+- ``bars``          section 20.5's one reading that remembers nothing
+- ``code_points``   section 10's whitespace set and the one string order
+- ``number_text``   `language.md` 5.5, how a number becomes text and back
+- ``strings``       section 10, the string calls
+- ``colour``        section 11, the nineteen names and the calls that compute one
+- ``stateless``     the manifest rows of the first half
+- ``series``        section 20.2's two shapes, and the region they are kept in
+- ``prices``        the two derived prices the second half forms for itself
+- ``averages``      section 20.3, the six means not built from another mean
+- ``composites``    section 20.3, the means built from those, and the fit
+- ``trend``         section 20.3, the studies that carry a decision from bar to bar
+- ``strength``      section 20.4, the position and strength readings
+- ``momentum``      section 20.4, the momentum readings and the two mean gaps
+- ``ranges``        section 20.5, the readings taken from the bar's own range
+- ``deviation``     section 20.5, the spread readings and the bands built on them
+- ``flows``         section 20.6, the volume readings
+- ``extremes``      sections 9 and 20.10, the window scans and the pivots
+- ``counting``      section 20.8, the totals, the ranks and the pair statistics
+- ``bookkeeping``   section 9, the comparisons and the two that wait on a condition
+- ``stateful``      the manifest rows of the second half
+
+**One thing this package will not do.** It raises nothing: a wrong argument is a
+diagnostic with a code and a span, produced by the checker or the interpreter
+before a call arrives, and every backstop here answers with absence instead
+(`stdlib.md` section 2.4). The memory ceilings are the interpreter's for the same
+reason, and ``MEASURED`` below is what it asks this package before it spends one:
+the two calls that can be asked for a string no engine could hold, and how long
+each of them will be before a character of it exists.
+
+**What a stateful call is handed that a stateless one is not** is the call site's
+own region, a plain mapping the engine created and owns, because
+`compiled-program.md` section 2.11 requires a region to be snapshottable by a
+mechanical copy without the engine knowing which function it belongs to. A
+stateless call needs none, which is what lets an engine call one of those from
+anywhere without a checkpoint or a rollback.
+
+**One family is not held to the vectors.** ``exp``, ``log``, ``log10``,
+``math.log2``, ``pow``, ``math.hypot`` and the trigonometric namespace reach gap 1
+of `stdlib.md` section 20.11, and so do ``alma``, ``hv`` and ``chop``, which are
+built on the first three: no portable reference algorithm is written down
+anywhere, so they call the host's maths module and carry no cross-engine
+guarantee. ``elementary`` says it again where an implementer will be standing.
+"""
+
+from .stateful import ENTRIES as STATEFUL_ENTRIES
+from .stateful import Entry as StatefulEntry
+from .stateful import table as stateful_table
+from .stateless import BUILDS_A_STRING, ENTRIES, MEASURED, Context, Entry, table
+
+__all__ = [
+    "ENTRIES",
+    "Context",
+    "Entry",
+    "BUILDS_A_STRING",
+    "MEASURED",
+    "STATEFUL_ENTRIES",
+    "StatefulEntry",
+    "stateful_table",
+    "table",
+]