plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/layers/grammar.py

@@ -0,0 +1,586 @@
+"""The grammar: a plot type as a declaration (:class:`Spec`) run by one engine
+(:func:`build`).
+
+A spec names its tables (built from the call's columns, or by a stat), its layers
+(:class:`Lay`: a geom, a paint role, the table it draws, when it is drawn, whether the
+legend symbol shows it), its legend entries, what it takes of the plot's colors and what the
+axes need.  The engine runs it: columns → tables (a stat's output, cached) → layers
+(orientation is one swap: ``flip``) → legend entries (symbols as data) → colors taken →
+axes.  A layer's ``stat`` runs once per call (:func:`~plot_io.layers.stats.run`; its
+output in ``build.stats`` for the table functions), and its ``position`` is asked of the
+tables it draws that hold ``heights`` (:func:`ask`): stacked, dodged or from 0; the
+positions run over the plot's calls (:mod:`~plot_io.layers.positions`).  :func:`top` reads a built call back: the highest value
+it draws over a span of the other axis (brackets).
+"""
+
+from typing import Any, Callable
+
+from .core import Call, Entry, Layer, Table
+from .geoms import GEOMS
+from .paint import Paint
+
+__all__ = ["Spec", "Lay", "Build", "build", "ask", "entry", "holds", "flipped", "axis_of", "top"]
+
+
+def flipped(series: Any) -> bool:
+    """Whether a series is drawn horizontally (``orientation="horizontal"``: its data's x
+    on the plot's y axis)."""
+    return "orientation" in series.SETTINGS and series.resolve("orientation") == "horizontal"
+
+
+def axis_of(series: Any, data_role: str = "x") -> Any:
+    """The plot axis a data role of ``series`` is drawn on."""
+    plot = series.plot
+    return plot.y_axis if flipped(series) == (data_role == "x") else plot.x_axis
+
+
+def holds(series: Any, cond: Any) -> bool:
+    """Whether condition ``cond`` holds for ``series``: ``None`` or ``True`` (always),
+    ``False`` (never), a setting name
+    (set to a true value), ``"name()"`` (a method's result), ``(name, value)`` or
+    ``(name, (values…))`` (a setting's value), or a function of the series."""
+    if cond is None or isinstance(cond, bool):
+        return cond is not False
+    if callable(cond):
+        return bool(cond(series))
+    if isinstance(cond, tuple):
+        name, want = cond
+        v = series.resolve(name)
+        return v in want if isinstance(want, tuple) else v == want
+    if cond.endswith("()"):
+        return bool(getattr(series, cond[:-2])())
+    return bool(series.resolve(cond))
+
+
+class Lay:
+    """One layer of a spec: ``geom`` (a name of :data:`~plot_io.layers.geoms.GEOMS`, or
+    ``"errors"``: the error bars of ``x_error``/``y_error``) drawing ``table`` with
+    ``paint = (role, options)`` (:class:`~plot_io.layers.paint.Paint`; an option ``"@name"``
+    is the paint of the layer ``name``, ``"#name"`` the table ``name``), ``when`` it holds (:func:`holds`).  ``key``: the
+    legend symbol shows it (``"first"``: its first table's layer only); ``drawn``: it is
+    drawn on the axes (not: a symbol part only); ``per_set``: the paint takes the index of
+    the table among the table list's (``index``), and consecutive per-set layers of one
+    table list are drawn set by set; ``turn``: drawn along the value axis (the geom's x on
+    the plot's y, violins).  ``stat``: the registered stat whose output the table
+    functions read (``build.stats[stat]``); ``position``: ``identity``, ``stack``,
+    ``dodge``… (:data:`~plot_io.layers.positions.NAMES`), asked of the layer's tables
+    (:func:`ask`).  ``occupy``, ``position`` and the other options (they go to the layer)
+    may be functions of the series."""
+
+    __slots__ = ("geom", "paint", "table", "aes", "when", "key", "occupy", "drawn", "name",
+                 "per_set", "stat", "position", "turn", "options")
+
+    def __init__(self, geom: str, paint: tuple[str, dict[str, Any]] | str,
+                 table: str = "data", aes: dict[str, str] | None = None, when: Any = None,
+                 key: Any = True, occupy: Any = True, drawn: bool = True,
+                 name: str | None = None, per_set: bool = False, stat: str = "identity",
+                 position: str | Callable[[Any], str] = "identity", turn: bool = False,
+                 **options: Any) -> None:
+        if geom != "errors" and geom not in GEOMS:
+            raise ValueError(f"unknown geom {geom!r} (geoms: {', '.join(GEOMS)}, errors)")
+        self.geom = geom
+        self.paint = (paint, {}) if isinstance(paint, str) else paint
+        self.table = table
+        self.aes = aes
+        self.when = when
+        self.key = key
+        self.occupy = occupy
+        self.drawn = drawn
+        self.name = name
+        self.per_set = per_set
+        self.stat = stat
+        self.position = position
+        self.turn = turn
+        self.options = options
+
+    def __repr__(self) -> str:
+        return f"Lay({self.geom!r}, {self.paint[0]!r}, table={self.table!r})"
+
+
+class Spec:
+    """A plot type as data (see the module docstring).
+
+    * ``layers``: the :class:`Lay` list, in drawing order;
+    * ``tables``: ``name → fn(series, build)`` giving a :class:`Table`, a list of them (one
+      per set) or ``None`` (the layers drawing it are left out); ``"data"`` defaults to the
+      columns ``x`` and ``y``;
+    * ``entries``: ``"name"`` (one entry, the ``name`` setting) or ``"sets"`` (one per set
+      of a dict of sets, or per text of a ``name`` tuple, else the ``name``); ``key``: the options of the entries' ``key``
+      paint (their ``(fill, stroke)``);
+    * ``color_count``: the plot's colors taken, ``"one"``, or one per ``"sets"``, unless
+      ``color`` is set;
+    * ``zero``: data roles that include 0 under ``include_zero="auto"`` (or a function of
+      the series giving them); ``titles``: data
+      arguments → data role of their axis titles (default ``x`` and ``y``);
+    * ``color_sources`` (a condition, :func:`holds`, or ``"items"``: numbers per item in
+      ``color``), ``size_sources``: the color and size settings mapped on the series' axes;
+    * ``slots``: the data argument of numeric slot positions of a categorical type (the
+      category axis: its categories, or the positions widened by half a slot);
+    * ``finish``: ``fn(series, build)`` run last (what no field declares);
+    * ``items``: the noun of the sets in messages.
+    """
+
+    __slots__ = ("layers", "tables", "entries", "key", "color_count", "zero", "titles",
+                 "color_sources", "size_sources", "slots", "finish", "items")
+
+    def __init__(self, layers: list[Lay], tables: dict[str, Callable[..., Any]] | None = None,
+                 entries: str = "name", key: dict[str, Any] | None = None,
+                 color_count: str = "one",
+                 zero: tuple[str, ...] | Callable[[Any], tuple[str, ...]] = (),
+                 titles: dict[str, str] | None = None, color_sources: Any = False,
+                 size_sources: bool = False, slots: str | None = None,
+                 finish: Callable[[Any, "Build"], None] | None = None,
+                 items: str = "sets") -> None:
+        names = [la.name for la in layers if la.name]
+        for la in layers:
+            for k, v in la.paint[1].items():
+                if isinstance(v, str) and v.startswith("@") and v[1:] not in names:
+                    raise ValueError(f"layer {la!r}: paint option {k}={v!r} names no layer")
+        self.layers = layers
+        self.tables = {"data": _data_table, **(tables or {})}
+        self.entries = entries
+        self.key = key or {}
+        self.color_count = color_count
+        self.zero = zero
+        self.titles = titles
+        self.color_sources = color_sources
+        self.size_sources = size_sources
+        self.slots = slots
+        self.finish = finish
+        self.items = items
+
+    def check(self, kind: str) -> None:
+        """Check the paint roles and their options, and the layer options of each geom
+        (``kind``: the type, named in the error).  Run at a type's first build: roles may
+        be registered after its spec."""
+        import inspect
+        from .geoms import LAYER_OPTIONS
+        from .paint import ROLES
+        from .stats import STATS
+        for lay in self.layers:
+            if lay.stat != "identity" and lay.stat not in STATS:
+                raise ValueError(f"{kind}: layer {lay!r}: unknown stat {lay.stat!r} (stats: "
+                                 f"identity, {', '.join(sorted(STATS))})")
+            if not callable(lay.position):
+                check_position(f"{kind}: layer {lay!r}", lay.position)
+        paints = [(la, la.paint[0], set(la.paint[1]) | ({"index"} if la.per_set else set()))
+                  for la in self.layers] + [(None, "key", set(self.key) | {"index"})]
+        for la, role, given in paints:
+            where = f"{kind}: " + ("legend key" if la is None else f"layer {la!r}")
+            if role not in ROLES:
+                raise ValueError(f"{where}: unknown paint role {role!r} (roles: "
+                                 f"{', '.join(sorted(ROLES))})")
+            params = inspect.signature(ROLES[role]).parameters
+            if not any(p.kind is p.VAR_KEYWORD for p in params.values()):
+                bad = sorted(given - set(list(params)[3:]))
+                if bad:
+                    raise ValueError(f"{where}: paint role {role!r} takes no option "
+                                     f"{bad[0]!r}")
+        for la in self.layers:
+            known = (("skip", "order") if la.geom == "errors"
+                     else GEOMS[la.geom].OPTIONS + LAYER_OPTIONS)
+            bad = sorted(set(la.options) - set(known))
+            if bad:
+                raise ValueError(f"{kind}: layer {la!r}: geom {la.geom!r} takes no option "
+                                 f"{bad[0]!r} (options: {', '.join(known)})")
+
+
+def check_position(kind: str, name: Any) -> str:
+    """A position name (:data:`~plot_io.layers.positions.NAMES`), else a ``ValueError``."""
+    from .positions import NAMES
+    if name not in NAMES:
+        raise ValueError(f"{kind}: unknown position {name!r} (positions: "
+                         f"{', '.join(NAMES)})")
+    return name
+
+
+def _data_table(s: Any, b: "Build") -> Table:
+    c = s.cols
+    return Table(x=c["x"], y=c["y"])
+
+
+class Build:
+    """The state of one run of a spec: the series, its call, ``flip`` (orientation), the
+    column functions of positions given as categories (``at``), the tables, the layers'
+    paints by name."""
+
+    def __init__(self, series: Any, call: Call, flip: bool) -> None:
+        self.series = series
+        self.call = call
+        self.flip = flip
+        self.at: dict[str, Any] = {}
+        self.tables: dict[str, Any] = {}
+        #: the output of each stat the layers declare (:func:`~plot_io.layers.stats.run`)
+        self.stats: dict[str, Any] = {}
+        self.paints: dict[str, Paint] = {}
+        #: the key layers in order, with the set they belong to (-1: every set)
+        self.symbol: list[tuple[int, Layer]] = []
+
+    def options(self, opts: dict[str, Any]) -> dict[str, Any]:
+        """Paint options: ``"@name"`` the paint of layer ``name``, ``"#name"`` the table
+        ``name``, a function of the series called."""
+        out = {}
+        for n, v in opts.items():
+            if isinstance(v, str) and v.startswith("@"):
+                v = self.paints[v[1:]]
+            elif isinstance(v, str) and v.startswith("#"):
+                v = self.tables[v[1:]]
+            elif callable(v):
+                v = v(self.series)
+            out[n] = v
+        return out
+
+    def paint(self, lay: "Lay", index: int | None = None) -> Paint:
+        """The paint of a layer (``index``: of its table among a list's)."""
+        role, opts = lay.paint
+        opts = self.options(opts)
+        if index is not None:
+            opts["index"] = index
+        return Paint(self.series, role, **opts)
+
+    def role(self, data_role: str) -> str:
+        """The plot axis a data role is drawn on."""
+        if not self.flip:
+            return data_role
+        return {"x": "y", "y": "x"}.get(data_role, data_role)
+
+
+#: the types whose spec was checked (:meth:`Spec.check`)
+_CHECKED: set[type] = set()
+
+
+def build(series: Any) -> Call:
+    """Run the spec of ``series``' type: its :class:`Call`."""
+    from ..presets._util import columns_meta, keyed
+    from .paint import color_sources, size_sources
+    from .stats import run as run_stat
+    spec: Spec = type(series).SPEC
+    if type(series) not in _CHECKED:
+        spec.check(type(series).__name__)
+        _CHECKED.add(type(series))
+    call = Call(series)
+    flip = flipped(series)
+    b = Build(series, call, flip)
+    b.at = keyed(call, series.cols.keys, flip, [])
+    lays = [la for la in spec.layers if holds(series, la.when)]
+    for name, fn in spec.tables.items():
+        drawing = [la for la in lays if la.table == name]
+        if drawing:
+            for la in drawing:
+                if la.stat != "identity" and la.stat not in b.stats:
+                    b.stats[la.stat] = run_stat(series, la.stat)
+            b.tables[name] = fn(series, b)
+    asked: set[int] = set()
+    for la in lays:
+        got = b.tables.get(la.table)
+        if got is not None:
+            ts = [t for t in (got if isinstance(got, list) else [got]) if id(t) not in asked]
+            asked.update(id(t) for t in ts)
+            ask(b, check_position(series.kind, _value(la.position, series)), ts)
+    for t in _all_tables(b.tables):
+        for name, fn in b.at.items():
+            if name in t and name not in t.lazy:
+                t.lazy[name] = fn
+    for lay in lays:
+        if lay.name:
+            b.paints[lay.name] = b.paint(lay)
+    for group in _groups(lays):
+        if group[0].geom == "errors":
+            call.layers += _errors(b, group[0])
+            continue
+        got = b.tables.get(group[0].table)
+        if got is None:
+            continue
+        many = isinstance(got, list)
+        for k, t in enumerate(got if many else [got]):
+            for lay in group:
+                _add(b, lay, t, k)
+    _entries(b, spec)
+    if spec.color_count == "sets":
+        call.color_count = 0 if series.is_set("color") else len(series.cols.sets)
+    else:
+        call.color_count = 0 if series.is_set("color") else 1
+    if spec.color_sources == "items":
+        call.color_sources = _item_colors(series)
+    elif holds(series, spec.color_sources):
+        call.color_sources = color_sources(series)
+    if spec.size_sources:
+        call.size_sources = size_sources(series)
+    call.zero = {b.role(r) for r in _value(spec.zero, series)}
+    titles = {"x": "y", "y": "x"} if flip else {}
+    if spec.titles is not None:
+        titles = {k: b.role(v) for k, v in spec.titles.items()}
+    columns_meta(call, titles)
+    if spec.slots is not None:
+        _slots(b, series.cols[spec.slots])
+    if spec.finish is not None:
+        spec.finish(series, b)
+    return call
+
+
+def ask(b: Build, position: str, tables: list[Table]) -> None:
+    """Ask ``position`` of the tables of a layer holding ``heights`` (per key: ``keys``)
+    that have no request of their own: ``stack`` piles them on the plot's stacked tables of
+    the type and orientation (``stack="normalize"``: as shares); ``dodge`` shares each key's
+    slot with the call's other sets; else each is drawn from 0 (``bottom``, ``top``).
+    Tables without ``heights`` are the type's to place."""
+    s = b.series
+    for k, t in enumerate(tables):
+        if "heights" not in t or t.stack is not None or "top" in t:
+            continue
+        if position == "stack":
+            if "keys" not in t:
+                raise ValueError(f"{s.kind}: position 'stack' needs keys (the table has "
+                                 f"{', '.join(t)})")
+            mode = s.resolve("stack") if "stack" in s.SETTINGS else True
+            t.stack = ((s.kind, b.flip), mode or True)
+            continue
+        if position == "dodge" and t.dodge is None and "keys" in t:
+            from .positions import Dodge
+            t.dodge = Dodge(s, (s.kind, id(s)), b.flip, t["keys"], token=k)
+        h = t["heights"]
+        t["bottom"], t["top"] = [0.0] * len(h), list(h)
+
+
+def _item_colors(s: Any) -> list[tuple[Any, Any]]:
+    """``(color axis, numbers)`` of numbers per item (a list, or a dict by category) in
+    ``color``."""
+    from array import array
+    from ..mapped import color_axis_of
+    from ..presets._util import per_category
+    from ..values import Values
+    c = s.resolve("color")
+    if not isinstance(c, Values):
+        return []
+    return [(color_axis_of(s), array("d", per_category(s, s.cols.categories, c.data,
+                                                        getattr(s, "ITEMS", "items"))))]
+
+
+def _slots(b: Build, positions: Any) -> None:
+    """The category axis: the categories, or numeric ``positions`` widened by half a
+    slot."""
+    from array import array
+    from .positions import slot_extent
+    s, call = b.series, b.call
+    cat = b.role("x")
+    if positions is None:
+        call.cats[cat] = list(s.cols.categories)
+        return
+    time = cat in call.times
+    call.extent_of[cat] = lambda scale: slot_extent(s, positions, time, scale)
+    call.extra[cat] = array("d", positions)
+
+
+def _groups(lays: list[Lay]) -> list[list[Lay]]:
+    """The layers in drawing groups: consecutive per-set layers of one table list are
+    drawn set by set (each set's layers together)."""
+    out: list[list[Lay]] = []
+    for la in lays:
+        prev = out[-1][-1] if out else None
+        if prev is not None and la.per_set and prev.per_set and la.table == prev.table:
+            out[-1].append(la)
+        else:
+            out.append([la])
+    return out
+
+
+def _add(b: Build, lay: Lay, t: Table, k: int) -> None:
+    """The layer of ``lay`` drawing table ``t`` (``k``: its index in its list)."""
+    s = b.series
+    paint = b.paints[lay.name] if lay.name else b.paint(lay, k if lay.per_set else None)
+    options = {n: _value(v, s) for n, v in lay.options.items()}
+    layer = Layer(GEOMS[lay.geom], t, aes=lay.aes, paint=paint, flip=b.flip != lay.turn,
+                  stat=lay.stat,
+                  position=_value(lay.position, s), occupy=_value(lay.occupy, s),
+                  key=bool(lay.key) and (lay.key != "first" or k == 0), **options)
+    if layer.key:
+        b.symbol.append((k if lay.per_set else -1, layer))
+    if lay.drawn:
+        b.call.layers.append(layer)
+
+
+def _value(v: Any, series: Any) -> Any:
+    """A spec value, or a function of the series giving it."""
+    return v(series) if callable(v) else v
+
+
+def _all_tables(tables: dict[str, Any]) -> list[Table]:
+    out = []
+    for t in tables.values():
+        if isinstance(t, list):
+            out.extend(t)
+        elif t is not None:
+            out.append(t)
+    return out
+
+
+def _errors(b: Build, lay: Lay) -> list[Layer]:
+    """The error bars of ``x_error`` and ``y_error`` (in ``order``; ``skip``: ``(role,
+    condition)``, a role whose bars another layer draws) at the data table's points."""
+    from ..presets.errors import error_layers, errors_of
+    s = b.series
+    source = b.paint(lay)
+    data = b.tables["data"]
+    xs = b.at.get("x", data["x"])
+    y = data["y"]
+    ys = b.at.get("y", y[0] if isinstance(y, list) else y)
+    skip = lay.options.get("skip")
+    out: list[Layer] = []
+    for role in lay.options.get("order", ("x", "y")):
+        e = errors_of(s, f"{role}_error")
+        if e is None:
+            continue
+        # one Errors per set (a summary of several sets) at each set's points
+        each = list(zip(e, y)) if isinstance(e, list) else [(e, ys)]
+        for e, _ in each:
+            e.bind(len(s.cols["x"]), s, f"{role}_error")
+        if role in s.cols.keys:
+            raise ValueError(f"{s.kind}: {role}_error needs numbers in {role}, not "
+                             "categories")
+        if skip is not None and skip[0] == role and holds(s, skip[1]):
+            continue
+        for e, at in each:
+            out += error_layers(s, e, xs, at, role == "x", source, b.flip)
+    return out
+
+
+def _entries(b: Build, spec: Spec) -> None:
+    """The call's legend entries, symbols as data."""
+    s = b.series
+    if spec.entries == "sets" and s.cols.named:
+        for i, (k, _) in enumerate(s.cols.sets):
+            layers = [la for j, la in b.symbol if j in (-1, i)]
+            b.call.entries.append(_entry(b, str(k), layers, spec, i))
+        return
+    name = s.resolve("name")
+    if spec.entries == "sets" and isinstance(name, tuple):
+        n = len(s.cols.sets)
+        if len(name) != n:
+            raise ValueError(f"{s.kind}: name has {len(name)} texts for {n} {spec.items}")
+        for i, label in enumerate(name):
+            layers = [la for j, la in b.symbol if j in (-1, i)]
+            b.call.entries.append(_entry(b, label, layers, spec, i))
+        return
+    if name is not None:
+        layers = [la for j, la in b.symbol if j in (-1, 0)]
+        b.call.entries.append(_entry(b, name, layers, spec, 0 if spec.entries == "sets"
+                                     else None))
+
+
+def _entry(b: Build, label: Any, layers: list[Layer], spec: Spec, index: Any) -> Entry:
+    opts = b.options(spec.key)
+    if index is not None:
+        opts["index"] = index
+    return entry(b.series, label, layers, **opts)
+
+
+def entry(series: Any, label: Any, layers: list[Layer], **key: Any) -> Entry:
+    """A legend entry whose symbol is the parts of ``layers`` (their key layers), with
+    the options ``key`` of its ``key`` paint (its simple symbol's colors)."""
+    parts, paints = [], []
+    for la in layers:
+        part = la.part() if la.key else None
+        if part is not None:
+            parts.append(part)
+            paints.append(la.paint)
+    return Entry(label, tuple(parts), tuple(paints), Paint(series, "key", **key))
+
+
+class _Map:
+    """A mapper placing data at ``a`` px per unit (:class:`_SlotContext`)."""
+
+    def __init__(self, a: float) -> None:
+        self.a = a
+
+    def __call__(self, v: float) -> float:
+        return v * self.a
+
+    position = __call__
+
+    def many(self, v: Any) -> Any:
+        from array import array
+        return array("d", (x * self.a for x in v))
+
+
+class _State:
+    __slots__ = ("categories", "scale")
+
+    def __init__(self, categories: list[Any]) -> None:
+        self.categories, self.scale = categories, None
+
+
+class _SlotContext:
+    """A drawing context before layout: each category at its index, lengths in px
+    negligible (a slot is 1e9 px), so lazy columns put items within their slots."""
+
+    def __init__(self, cats: dict[str, list[Any]]) -> None:
+        self.root = self
+        self.x, self.y = _State(cats.get("x", [])), _State(cats.get("y", []))
+        self.xmap = self.ymap = _Map(1e9)
+        self.cycle: tuple = ()
+        self.rect = (0.0, 0.0, 1.0, 1.0)
+
+    def color(self, value: Any) -> Any:
+        from ..color.values import resolve_color
+        return resolve_color(value, self.cycle)
+
+
+def top(call: Call, lo: float, hi: float, role: str, cats: dict[str, list[Any]]) -> float:
+    """The highest finite value ``call``'s layers draw on the plot axis ``role`` (``"y"``
+    or ``"x"``) at positions in [``lo``, ``hi``] on the other axis (the middle of each
+    item's position columns; category units on a category axis, ``cats``: the axes'
+    categories); ``-inf`` when none.  Columns that need the placed axes are read with each
+    category at its index; a layer they fail for counts whole."""
+    import math
+    other = "x" if role == "y" else "y"
+    best = -math.inf
+    ctx: Any = None
+    for layer in call.layers:
+        vch = layer.geom.CHANNELS.get(layer.frame_role(role), ())
+        pch = layer.geom.CHANNELS.get(layer.frame_role(other), ())
+        if not vch:
+            continue
+        if layer.table.lazy:
+            ctx = ctx or _SlotContext(cats)
+            try:
+                layer = layer.columns(ctx)
+            except Exception:                   # noqa: BLE001 — counted whole below
+                pch = ()
+        vals = [_arrays(layer.col(c)) for c in vch]
+        poss = [_arrays(layer.col(c)) for c in pch] if pch else []
+        for k in range(max((len(v) for v in vals), default=0)):
+            vs = [v[k] if k < len(v) else None for v in vals]
+            ps = [p[k] if k < len(p) else None for p in poss]
+            best = max(best, _top_rows(vs, ps, lo, hi))
+    return best
+
+
+def _arrays(v: Any) -> list[Any]:
+    """The arrays of a channel (several for a list of arrays; a constant as itself)."""
+    if v is None:
+        return []
+    if isinstance(v, list) and v and hasattr(v[0], "__len__"):
+        return v
+    return [v]
+
+
+def _top_rows(vs: list[Any], ps: list[Any], lo: float, hi: float) -> float:
+    import math
+    best = -math.inf
+    n = max((len(v) for v in vs + ps if hasattr(v, "__len__")), default=1)
+
+    def at(c: Any, i: int) -> float:
+        if c is None:
+            return math.nan
+        return float(c[i]) if hasattr(c, "__len__") else float(c)
+    for i in range(n):
+        if ps:
+            p = [at(c, i) for c in ps]
+            p = [x for x in p if math.isfinite(x)]
+            if not p or not lo <= (min(p) + max(p)) / 2 <= hi:
+                continue
+        for c in vs:
+            v = at(c, i)
+            if v > best and math.isfinite(v):
+                best = v
+    return best