plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/presets/dots.py

@@ -0,0 +1,355 @@
+"""Dots: one marker per cell of a grid (rows × columns), its size and color mapping values
+through the series' size and color axes (the dot plot)."""
+
+import array
+import math
+from typing import TYPE_CHECKING, Any, Self, Unpack
+
+from vec_io.arrays import doubles
+
+from .. import groups, kernels
+from ..layers.base import Series, common
+from ..layers.core import Call, Layer, Table
+from ..layers.geoms import GEOMS
+from ..layers.grammar import entry
+from ..layers.paint import Paint, color_sources, size_sources
+from ..settings import Setting, canonical_kwargs, one_of, table
+from ..transform import settings_both as coord_settings
+from ._util import columns_meta
+from .heatmap import Coords
+
+if TYPE_CHECKING:
+    from ..types import DotsSettings
+
+__all__ = ["Dots", "group_summary"]
+
+_NAN = float("nan")
+
+
+def _grid(v: Any, what: str) -> tuple[int, int, array.array] | None:
+    """``(rows, columns, values)`` of a 2-D grid of numbers, else ``None`` (one value)."""
+    if v is None or isinstance(v, (str, int, float, tuple)):
+        return None
+    g = kernels.grid(v)
+    if g is not None:
+        h, w, k, flat = g
+        if k != 1:
+            raise ValueError(f"{what}: a grid of numbers, one per cell")
+        return h, w, flat
+    rows = list(v)
+    if not rows or not all(not isinstance(r, (str, bytes)) and hasattr(r, "__len__")
+                           for r in rows):
+        raise ValueError(f"{what}: a grid of values (rows of cells), or long data (x, y "
+                         f"and {what} per cell)")
+    w = len(rows[0])
+    if any(len(r) != w for r in rows):
+        raise ValueError(f"{what}: rows of one length")
+    try:
+        flat = doubles([x for r in rows for x in r])
+    except (TypeError, ValueError):
+        raise ValueError(f"{what}: numbers per cell") from None
+    return len(rows), w, flat
+
+
+def _is_grid(v: Any) -> bool:
+    if v is None or isinstance(v, (str, int, float, tuple)):
+        return False
+    if kernels.grid(v) is not None:
+        return True
+    try:
+        first = next(iter(v))
+    except (TypeError, StopIteration):
+        return False
+    return not isinstance(first, (str, bytes)) and hasattr(first, "__len__")
+
+
+def _categories(given: Any, values: list[Any], order: list[Any] | None) -> list[Any]:
+    from ..tables import is_missing
+    if given is not None:
+        return list(given)
+    out = list(order or [])
+    seen = set(out)
+    for v in values:
+        if not is_missing(v) and v not in seen:
+            seen.add(v)
+            out.append(v)
+    return out
+
+
+def _center(c: Coords, i: int) -> float:
+    if c.kind in ("index", "category"):
+        return float(i)
+    if c.kind == "centers":
+        return c.values[i]
+    return (c.values[i] + c.values[i + 1]) / 2
+
+
+class Dots(Series):
+    """One marker per cell of a grid: ``color`` and ``size`` are grids of values (row 0
+    first) of one shape, or one value; ``x``/``y`` label the columns and rows, as
+    ``heatmap``'s.  With long data (``x``, ``y`` and values per cell), the cells come from
+    the rows; cells without a row get no dot.
+
+    Values always map: colors through the series' `color axis <docs/api.md#6-color-and-size-axes>`_ (a colorbar by default),
+    sizes through its size axis (``size_map`` ``(0, 12)`` px and ``size_limits``
+    ``"0/max"``: area ∝ value; fractions: ``"0/1"``) and its
+    `size key <docs/api.md#size-keys>`_, on the colorbar's line when both fit.  A missing size
+    leaves the cell empty; a missing color takes the map's ``bad``.
+
+    - Long data: ``x``, ``y`` and ``color``/``size`` per cell (columns with ``data=``, or
+      sequences), one row per cell; two rows for one cell are an error.  Categories in order
+      of first appearance (pandas or polars categoricals: theirs); ``x_categories=`` /
+      ``y_categories=`` lists select and order them.
+    - ``scale_color``: ``"rows"`` / ``"columns"`` rescales color values to 0–1 in each row or
+      column before mapping (one variable's range per column).
+    - Cells: the axes' width (``Figure(width=…)``) sets the space per column; rotated labels
+      closer than ``category_label_spacing`` are thinned out.  ``data_ratio=1`` on the plot
+      makes cells square.
+
+    Example::
+
+        rng = random.Random(1)
+        genes, clusters = ["Cd3e", "Ms4a1", "Lyz2", "Nkg7"], ["T", "B", "Mono"]
+        p = plt.Plot(width=240, height=160)
+        p.dots([[rng.random() for _ in genes] for _ in clusters],
+               size=[[rng.random() for _ in genes] for _ in clusters], x=genes, y=clusters,
+               size_limits="0/1")
+    """
+
+    DATA = {"color": "raw", "size": "raw", "x": "cells", "y": "cells"}
+    SETTINGS = table(
+        **coord_settings(),
+        **groups.Marker.embed(),
+        **common("color_map", "size_map", "size_key"),
+        scale_color=Setting(one_of("rows", "columns"),
+                            doc="`rows` / `columns`: color values rescaled to 0–1 in each "
+                                "row or column before mapping; unset: as given."),
+        origin=Setting(one_of("top", "bottom"),
+                       doc="`top`: row 0 at the top (y axis inverted); `bottom`: at the "
+                           "bottom."),
+        **common("name", "opacity", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    def __init__(self, color: Any = None, size: Any = None, x: Any = None, y: Any = None,
+                 plot: Any = None, **settings: Any) -> None:
+        args = {n: self.cols[n] for n in ("color", "size", "x", "y")}
+        _cells(args, settings, self.cols.orders)
+        color, size, x, y = args["color"], args["size"], args["x"], args["y"]
+        present = settings.pop("_present", None)
+        shape = settings.pop("_shape", None)
+        for k in ("x_categories", "y_categories"):
+            if k in settings:
+                raise ValueError(f"{k} applies to long data (x, y and values per cell)")
+        shapes = {}
+        for name, v in (("color", color), ("size", size)):
+            g = _grid(v, name)
+            if g is not None:
+                shapes[name] = (g[0], g[1])
+            elif v is not None:
+                settings[name] = v
+        if len(set(shapes.values())) > 1:
+            raise ValueError("color and size grids must have one shape, got "
+                             + " and ".join(f"{h}×{w}" for h, w in shapes.values()))
+        if shapes:
+            shape = next(iter(shapes.values()))
+        if shape is None:
+            raise ValueError("dots need color or size as a grid of values (rows of cells), "
+                             "or long data: x, y and values per cell")
+        self.h, self.w = shape
+        self.xc = Coords(x, self.w, "x")
+        self.yc = Coords(y, self.h, "y")
+        #: the cells drawn, row by row: ``(row, column)``
+        self.cells = [(r, c) for r in range(self.h) for c in range(self.w)
+                      if present is None or present[r * self.w + c]]
+        self.x = array.array("d", (_center(self.xc, c) for _, c in self.cells))
+        self.y = array.array("d", (_center(self.yc, r) for r, _ in self.cells))
+        self._given: dict[str, array.array] = {}
+        for name, v in (("color", color), ("size", size)):
+            if name in shapes:
+                settings[name] = v
+        super().__init__(plot=plot, **settings)
+
+    # -- values per cell ------------------------------------------------------------
+
+    def set(self, **given: "Unpack[DotsSettings]") -> Self:  # type: ignore[override]
+        settings = canonical_kwargs(dict(given), self.SETTINGS, self.kind)
+        for name in ("color", "size"):
+            if name not in settings:
+                continue
+            g = _grid(settings[name], name) if _is_grid(settings[name]) else None
+            if g is None:
+                self._given.pop(name, None)
+                continue
+            h, w, flat = g
+            if (h, w) != (self.h, self.w):
+                raise ValueError(f"{name}: a {self.h}×{self.w} grid, got {h}×{w}")
+            settings[name] = self._given[name] = array.array(
+                "d", (flat[r * w + c] for r, c in self.cells))
+        super().set(**settings)
+        if ("color" in settings or "scale_color" in settings) and "color" in self._given:
+            raw = self._given["color"]
+            super().set(color=raw if self.resolve("scale_color") is None
+                        else self._scaled(raw))
+        return self
+
+    def _scaled(self, values: array.array) -> array.array:
+        """Color values rescaled to 0–1 in each row (``scale_color="rows"``) or column."""
+        by = 0 if self.resolve("scale_color") == "rows" else 1
+        spans: dict[int, list[float]] = {}
+        for (r, c), v in zip(self.cells, values):
+            if math.isfinite(v):
+                k = (r, c)[by]
+                lo, hi = spans.get(k, (v, v))
+                spans[k] = [min(lo, v), max(hi, v)]
+        out = array.array("d")
+        for (r, c), v in zip(self.cells, values):
+            lo, hi = spans.get((r, c)[by], (0.0, 0.0))
+            out.append(_NAN if not math.isfinite(v) else
+                       (v - lo) / (hi - lo) if hi > lo else 0.0)
+        return out
+
+    def _bar_source(self) -> Any:
+        return self if "color" in self._given else None      # color values only
+
+    # -- drawing --------------------------------------------------------------------
+
+    def layers(self) -> Call:
+        call = Call(self)
+        n = len(self.cells)
+        t = Table(x=self.x, y=self.y)
+        size = self.resolve("size")
+        call.layers.append(Layer(GEOMS["points"], t, paint=Paint(self, "marker", n=n, once=True),
+                                 occupy="all",
+                                 radius=size / 2 if isinstance(size, (int, float)) else 0.0))
+        name = self.resolve("name")
+        if name is not None:
+            call.entries.append(entry(self, name, call.layers, fill="marker",
+                                      stroke="marker", marker=call.layers[0].paint))
+        call.color_count = 0 if self.is_set("color") else 1
+        call.color_sources = color_sources(self)
+        call.size_sources = size_sources(self)
+        self.xc.axis(call, "x")
+        self.yc.axis(call, "y")
+        if self.resolve("origin") == "top":
+            call.invert = {"y"}
+        call.exact = {"x", "y"}
+        columns_meta(call, {})
+        return call
+
+
+def group_summary(values: Any, groups: Any, names: Any = None, threshold: float = 0.0,
+                  mean: str = "all") -> dict[str, list[Any]]:
+    """Per group and variable of an observations × variables matrix: the ``mean`` and the
+    ``fraction`` of observations above ``threshold``, as columns for ``data=``
+    (``group``, ``name``, ``mean``, ``fraction``).
+
+    ``groups``: one label per observation (row); ``names``: the variables (default:
+    their indices).  ``mean="expressed"`` averages only the observations above
+    ``threshold`` (none: a missing mean).  Non-finite values are left out of both, per
+    cell.  Groups in order of first appearance (a pandas or polars categorical: its
+    order); missing labels are left out."""
+    from ..tables import is_missing
+    if mean not in ("all", "expressed"):
+        raise ValueError("mean is 'all' or 'expressed'")
+    g = kernels.grid(values)
+    if g is not None:
+        h, w, k, flat = g
+        if k != 1:
+            raise ValueError("values: a 2-D matrix")
+    else:
+        rows = [list(r) for r in values]
+        h, w = len(rows), len(rows[0]) if rows else 0
+        if any(len(r) != w for r in rows):
+            raise ValueError("values: rows of one length")
+        flat = doubles([v for r in rows for v in r])
+    order = None
+    cat = getattr(groups, "cat", None)
+    if cat is not None:
+        try:
+            order = list(cat.categories)
+        except (AttributeError, TypeError):
+            try:
+                order = list(cat.get_categories())
+            except (AttributeError, TypeError):
+                order = None
+    if hasattr(groups, "to_numpy"):
+        groups = groups.to_numpy()
+    labels = list(groups.tolist() if hasattr(groups, "tolist") else groups)
+    if len(labels) != h:
+        raise ValueError(f"{len(labels)} group labels for {h} observations")
+    names = list(range(w)) if names is None else list(names)
+    if len(names) != w:
+        raise ValueError(f"{len(names)} names for {w} variables")
+    from .._native import kernels as _native
+    keys = _categories(None, labels, order)
+    index = {k: i for i, k in enumerate(keys)}
+    rows_group = array.array("q", [-1]) * h
+    for r, lab in enumerate(labels):
+        if is_missing(lab) or lab not in index:
+            continue
+        rows_group[r] = index[lab]
+    total, count, above, total_above = _native.group_summary(flat, h, w, rows_group, len(keys),
+                                                             float(threshold))
+    out: dict[str, list[Any]] = {"group": [], "name": [], "mean": [], "fraction": []}
+    for gi, k in enumerate(keys):
+        for c in range(w):
+            i = gi * w + c
+            n = count[i]
+            out["group"].append(k)
+            out["name"].append(names[c])
+            if mean == "all":
+                out["mean"].append(total[i] / n if n else _NAN)
+            else:
+                m = above[i]
+                out["mean"].append(total_above[i] / m if m else _NAN)
+            out["fraction"].append(above[i] / n if n else _NAN)
+    return out
+
+
+def _cells(pos: dict[str, Any], kw: dict[str, Any], orders: dict[str, Any]) -> None:
+    """Long data: ``x``, ``y`` and values per cell (one row per cell) into grids (in
+    ``pos``; the grid's shape and the cells present in ``kw``)."""
+    from ..tables import is_missing
+    x, y = pos.get("x"), pos.get("y")
+    given = {n: pos[n] for n in ("color", "size") if pos.get(n) is not None}
+    if x is None or y is None or any(_is_grid(v) for v in given.values()):
+        return
+    per_cell = {n: v for n, v in given.items()
+                if not isinstance(v, (str, int, float, tuple))}
+    xs, ys = list(x), list(y)
+    if len(xs) != len(ys):
+        raise ValueError(f"x has {len(xs)} values and y {len(ys)}")
+    vals: dict[str, array.array] = {}
+    for n, v in per_cell.items():
+        try:
+            vals[n] = doubles(v)
+        except (TypeError, ValueError):
+            raise ValueError(f"{n}: numbers per cell") from None
+        if len(vals[n]) != len(xs):
+            raise ValueError(f"{n} has {len(vals[n])} values for {len(xs)} cells")
+    xcats = _categories(kw.pop("x_categories", None), xs, orders.get("x"))
+    ycats = _categories(kw.pop("y_categories", None), ys, orders.get("y"))
+    xi = {v: i for i, v in enumerate(xcats)}
+    yi = {v: i for i, v in enumerate(ycats)}
+    h, w = len(ycats), len(xcats)
+    if not h or not w:
+        raise ValueError("dots: no cells")
+    present = bytearray(h * w)
+    grids = {n: array.array("d", [_NAN]) * (h * w) for n in vals}
+    for k, (a, b) in enumerate(zip(xs, ys)):
+        if is_missing(a) or is_missing(b) or a not in xi or b not in yi:
+            continue
+        i = yi[b] * w + xi[a]
+        if present[i]:
+            raise ValueError(f"two rows for the cell ({a!r}, {b!r})")
+        present[i] = 1
+        for n, g in grids.items():
+            g[i] = vals[n][k]
+    pos["x"] = [v if isinstance(v, str) else str(v) for v in xcats]
+    pos["y"] = [v if isinstance(v, str) else str(v) for v in ycats]
+    kw["_shape"] = (h, w)
+    for n, g in grids.items():
+        pos[n] = [g[r * w:(r + 1) * w] for r in range(h)]
+    if not all(present):
+        kw["_present"] = present

plot_io/presets/ecdf.py

@@ -0,0 +1,97 @@
+"""Empirical cumulative distributions (stat ``ecdf``): a step line (``Path``) per set."""
+
+import array
+from typing import Any
+
+from .._methods import EcdfMixin
+from .. import columns, groups
+from ..layers import stats
+from ..layers.base import Series, common
+from ..layers.core import Table
+from ..layers.grammar import Lay, Spec
+from ..layers.positions import check_stack
+from ..settings import Setting, boolean, one_of, table
+from ..transform import settings_both as coord_settings
+from ..layers.paint import base_colors
+from ._util import faded, set_color_value
+
+__all__ = ["Ecdf"]
+
+
+class Ecdf(EcdfMixin, Series):
+    """The empirical cumulative distribution of ``values`` (one array, or several as a dict
+    or a list of arrays).
+
+    A step line through the sorted values of each set: ``stat`` ``proportion``, ``count`` or
+    ``percent``; ``complementary`` plots 1 − F.  ``color``: one, a list (one per set) or a
+    dict by set name.
+
+    Example::
+
+        rng = random.Random(1)
+        p = plt.Plot(width=240, height=160)
+        p.ecdf({"a": [rng.gauss(0, 1) for _ in range(80)],
+                "b": [rng.gauss(0.8, 1.2) for _ in range(80)]})
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        weights=Setting(columns.weights, doc="A weight per value (per set for several sets)."),
+        stat=Setting(one_of("proportion", "count", "percent"),
+                     doc="`proportion` (0–1), `count` or `percent`."),
+        complementary=Setting(boolean, doc="Plot 1 − F (survival)."),
+        stack=Setting(check_stack, doc="Stack the sets, and the plot's other stacked ecdf "
+                                       "calls, on their values (`\"normalize\"`: as "
+                                       "shares)."),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical`: values along x; `horizontal`: along y."),
+        color=Setting(set_color_value,
+                      doc="Line color, one per set (a list, or a dict by set name); default "
+                          "the plot's colors."),
+        **groups.Stroke.embed(only=("line_width", "line_style"),
+                              inherited=("line_width",),
+                              docs={"line_style": "Line style."}),
+        **common("name", "opacity", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    DATA = {"values": "samples"}
+
+    def __init__(self, values: Any, plot: Any = None, **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    @property
+    def stats(self) -> list[tuple[array.array, array.array, float]]:
+        """Per set: sorted values, the plotted cumulative values, and the value before the
+        first step (0, or the total for complementary curves)."""
+        return stats.run(self, "ecdf")
+
+    def _colors(self, ctx: Any) -> list[Any]:
+        cols = base_colors(self, ctx, [k for k, _ in self.cols.sets])
+        return faded(cols, self.resolve("opacity"))
+
+    def _line_colors(self, ctx: Any) -> list[Any]:
+        """Each set's line color (none for a set without values)."""
+        return [c if len(st[0]) else None for c, st in zip(self._colors(ctx), self.stats)]
+
+    SPEC = Spec(
+        [Lay("path", ("stroke", {"color": "_line_colors()", "dash": True,
+                                 "extra": ("simplify",),
+                                 "fixed": {"interpolation": "step-post"}}),
+             table="sets", per_set=True, aes={"y": "top"}, stat="ecdf",
+             position=lambda s: "stack" if s.resolve("stack") else "identity",
+             interpolation="step-post")],
+        tables={"sets": lambda s, b: [_steps(xs, ys, start) for xs, ys, start in b.stats["ecdf"]]},
+        entries="sets", key={"stroke": "_colors()"}, color_count="sets", titles={"values": "x"})
+
+
+def _steps(xs: Any, ys: Any, start: float) -> Table:
+    """A set's step line: from the value before the first step (its key ``None``)."""
+    if len(xs):
+        vx = array.array("d", [xs[0]])
+        vx.extend(xs)
+        cy = array.array("d", [start])
+        cy.extend(ys)
+    else:
+        vx, cy = array.array("d"), array.array("d")
+    return Table(x=vx, keys=[None, *xs[:len(vx) - 1]], heights=cy)

plot_io/presets/errorbar.py

@@ -0,0 +1,106 @@
+"""Error bars on their own (``Segments``, or a ``Band`` for y errors), with optional markers
+(``Points``)."""
+
+import array
+from typing import Any
+
+from .._methods import ErrorbarMixin
+from .. import groups
+from ..color.values import color
+from ..layers.base import column, common
+from ..layers.core import Table
+from ..layers.grammar import Lay, Spec
+from ..layers.paint import xy_density_points
+from ..settings import Setting, number, one_of, table
+from ..transform import settings_both as coord_settings
+from ..validators import length
+from .errors import Summarized, error_value, errors_of
+
+__all__ = ["Errorbar"]
+
+
+def _marker(v: Any) -> Any:
+    from ..markers import check_marker
+    return check_marker(v)
+
+
+class Errorbar(ErrorbarMixin, Summarized):
+    """Error bars at ``(x, y)``: ``y_error``/``x_error`` as a value, a sequence,
+    ``(low, high)`` or ``Errors``; ``marker`` adds markers at the points (numbers per
+    point in ``marker_color`` map through the series' color axis).
+
+    Markers only with ``marker=``; ``y_error_style="band"`` fills the band between the y
+    error ends instead.  With replicates, ``estimate`` and ``interval`` draw points at their
+    estimates with bars of their interval (a point plot; `summaries <docs/api.md#summaries-estimate-interval>`_).
+
+    Example::
+
+        p = plt.Plot(width=240, height=160)
+        p.errorbar(range(6), [2, 3, 2.5, 4, 3.5, 5], y_error=[0.4, 0.6, 0.3, 0.8, 0.5, 0.7], marker="o")
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        **{**groups.Marker.embed("marker_"),
+           "marker": Setting(_marker, doc="Marker at the points; default none.")},
+        **common("color_map"),
+        color=Setting(color, doc="Bar color; default: the plot's next color."),
+        line_width=Setting(length(lo=0), inherited=True, doc="Bar width."),
+        cap_length=Setting(length(lo=0, data=True),
+                           doc="Cap width (`data`: in data units across the bar); 0: no "
+                               "caps."),
+        x_error=Setting(error_value, doc="Horizontal errors."),
+        y_error=Setting(error_value, doc="Vertical errors."),
+        y_error_style=Setting(one_of("bars", "band"),
+                              doc="`bars`, or `band`: a filled band between the y error ends "
+                                  "(points sorted by x)."),
+        band_opacity=Setting(number(0, 1), doc="Opacity of a band."),
+        **common("estimate"),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical` (x along the x axis) or `horizontal` (x along "
+                                "the y axis)."),
+        **common("name", "opacity", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    DATA = {"x": "position", "y": "position"}
+    x = column("x", "x of each point (categories at their index among their own).")
+    y = column("y", "y of each point (as x).")
+
+    def __init__(self, x: Any, y: Any, plot: Any = None, **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    def density_points(self) -> tuple[Any, Any]:
+        """The markers' positions on the plot's axes (a density in ``marker_color``)."""
+        return xy_density_points(self, self.x, self.y)
+
+    SPEC = Spec(
+        [Lay("band", ("band", {"color": "faded", "opacity": "band_opacity"}), table="band",
+             key=False, occupy=False),
+         Lay("errors", ("error_source", {"color": "faded", "width": "line_width",
+                                         "opacity": 1.0}),
+             order=("y", "x"), skip=("y", ("y_error_style", "band"))),
+         # the legend symbol: a bar with caps (not drawn on the axes) and a marker
+         Lay("segments", ("stroke", {"color": "faded"}), table="symbol", drawn=False,
+             glyph="errorbar"),
+         Lay("points", ("marker", {"prefix": "marker_", "color": "faded", "when": "marker",
+                                   "n": lambda s: len(s.x)}),
+             glyph_max=0.8)],
+        tables={"band": lambda s, b: _band(s), "symbol": lambda s, b: Table()},
+        key={"stroke": "faded"}, color_sources=lambda s: s.resolve("marker") is not None)
+
+
+def _band(s: Errorbar) -> Table | None:
+    """``y_error_style="band"``: the band between the y error ends, points sorted by x."""
+    e = errors_of(s, "y_error")
+    if e is None or s.resolve("y_error_style") != "band":
+        return None
+    e.bind(len(s.x), s, "y_error")
+    if "x" in s.cols.keys:
+        raise ValueError("Errorbar: y_error_style=\"band\" needs numbers in x, not "
+                         "categories")
+    lo, hi = e.ends(s.y)
+    order = sorted(range(len(s.x)), key=lambda i: s.x[i])
+    return Table(x=array.array("d", (s.x[i] for i in order)),
+                 y1=array.array("d", (lo[i] for i in order)),
+                 y2=array.array("d", (hi[i] for i in order)))