jarvisplot 2.1.1__tar.gz → 2.1.2__tar.gz

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.1
+Version: 2.1.2
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.1
+Version: 2.1.2
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/jarvisplot/Figure/corr_layout_diamond.py

@@ -63,6 +63,15 @@ def diamond_extent(n: int, *, diag: bool = False) -> tuple[float, float, float,
 
     With ``diag`` the self-pairs come in at ``u = 0`` and push both ranges out
     by half a cell.
+
+    A half, not the quarter the pentagon of
+    :func:`corrplot_runtime._self_cell_vertices` actually reaches: that shape
+    is how a *fill* keeps a whole cell's area against the edge, and the round
+    glyphs do not take it.  A circle on the diagonal is a circle, and at the
+    quarter it overhung the panel by 0.07 cells -- which is only 0.3 mm, but it
+    is 0.3 mm off the one gap the eye checks, the channel between the matrix
+    and the names, and it narrowed it on the diagonal rows alone.  The panel
+    buys the half so that every glyph fits whatever shape it is.
     """
     n = max(int(n), 2)
     if diag:

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/jarvisplot/Figure/corrplot_runtime.py

@@ -161,6 +161,14 @@ _DIAMOND_ROUND = 1.0 / np.sqrt(2.0)
 #: because a divider that is *nearly* the cell divider reads as a mistake.
 _GRID_LWD = 0.3
 
+#: Where the tint sits: under everything.  It is the background the figure is
+#: drawn *on*, so it takes the lowest layer on the axes rather than one derived
+#: from the glyph's -- an axis draws its own tick labels at 2.5, and a tint
+#: placed relative to the glyphs lands above that and prints over the names.
+#: Its three pieces (the cells, the notch, the band under the label) are one
+#: band and share one number, so they cannot drift apart.
+_TINT_ZORDER = 0.4
+
 #: Square glyphs are a polygon per cell and nothing else, so they skip the
 #: patch objects entirely -- see :func:`_glyph_vertices`.
 _POLYGON_GLYPHS = ("square", "color", "shade")
@@ -171,21 +179,87 @@ _POLYGON_GLYPHS = ("square", "color", "shade")
 _FILLED_GLYPHS = ("color", "shade")
 
 
-def _notch_vertices(n: int, side: str = "left"):
+#: How far a self cell reaches past the matrix's near edge, in cells.  See
+#: :func:`_self_cell_vertices` -- it is what makes the pentagon's area a cell.
+_SELF_REACH = 0.25
+
+
+def _self_cell_vertices(rows, side: str = "left", scale: float = 1.0):
+    """``(m, 5, 2)`` outlines for the cells on the diagonal.
+
+    A variable's pair with *itself* sits at ``u = 0``, so half of an ordinary
+    cell would hang off the matrix and print over the names.  Clipping it
+    instead leaves a triangle -- half the area of every other cell, which reads
+    as a fainter diagonal rather than as the constant it is.
+
+    So it is neither: the cell keeps its point into the matrix and is squared
+    off on the outside, and the rectangle that squares it off is exactly deep
+    enough to pay back what the clip took.  The triangle is ``1/4``, the
+    rectangle is ``a x 1``, so ``a = 1/4`` puts the pentagon at ``1/2`` -- the
+    area of a whole cell, for every variable, which is the only way a diagonal
+    of constant rho can look constant.
+
+    It fits without moving anything: the wedge beside each name is empty by
+    construction (see :func:`_notch_vertices`, which is what used to fill it)
+    and the quarter cell outside is page the panel takes from the gap.
+
+    ``scale`` shrinks it about ``(0, k)`` exactly as ``glyph.scale`` shrinks
+    every other cell.  Without it these are the only shapes on the figure drawn
+    at full size, and since they also stack without a gap in ``v`` they fuse
+    into one bar down the edge instead of reading as a cell each.
+    """
+    k = np.asarray(rows, dtype=float)
+    flip = -1.0 if side == "right" else 1.0
+    zero = np.zeros_like(k)
+    half = 0.5 * float(scale)
+    back = flip * -2.0 * _SELF_REACH * half + zero
+    point, edge = flip * half + zero, half
+    return np.stack(
+        [
+            np.stack([back, k - edge], axis=1),
+            np.stack([zero, k - edge], axis=1),
+            np.stack([point, k], axis=1),
+            np.stack([zero, k + edge], axis=1),
+            np.stack([back, k + edge], axis=1),
+        ],
+        axis=1,
+    )
+
+
+def _notch_vertices(n: int, side: str = "left", diag: bool = False):
     """The half cells that make the matrix's near edge straight.
 
-    A variable's V has its vertex at ``(0, k)``, and the two cells meeting
-    there touch the edge at a point, not along it -- so the boundary beside the
-    names comes out as a row of notches.  The notch at ``k`` is the triangle
-    ``(0, k-1/2) (1/2, k) (0, k+1/2)``: filling it with that variable's own
-    tint carries the band from the name into the matrix without a gap, and
-    turns the sawtooth into the straight edge the rules can close against.
+    Whatever stands at ``u = 0`` meets the edge beside the names at a *point*,
+    so that boundary comes out as a row of notches and the tint carrying a
+    variable's band in from its name pinches to nothing there.  Filling the
+    notch is what turns the sawtooth into the straight edge the rules close
+    against, and the band into one band.
+
+    The diagonal moves the notch, it does not remove it -- which is what an
+    earlier version of this card assumed, and the band broke on every shaded
+    row.  Without the diagonal the near edge is ``u = 0`` and the first cells
+    are the pairs at ``u = 1/2``, so the gap is the triangle
+    ``(0, k-1/2) (1/2, k) (0, k+1/2)`` *inside* the matrix.  With it the near
+    edge is ``u = -1/2`` and the self cell's own left corner is the point, so
+    the gap is the pair of triangles either side of it -- together with that
+    corner, the rectangle ``[-1/2, 0] x [k-1/2, k+1/2]``.
 
     Returned for every variable; the caller picks the tinted ones.
     """
     k = np.arange(int(n), dtype=float)
     flip = -1.0 if side == "right" else 1.0
     zero = np.zeros_like(k)
+    if diag:
+        back = flip * -0.5 + zero
+        return np.stack(
+            [
+                np.stack([back, k - 0.5], axis=1),
+                np.stack([zero, k - 0.5], axis=1),
+                np.stack([zero, k + 0.5], axis=1),
+                np.stack([back, k + 0.5], axis=1),
+            ],
+            axis=1,
+        )
     return np.stack(
         [
             np.stack([zero, k - 0.5], axis=1),
@@ -329,13 +403,25 @@ def _label_rules(ax, n: int, span, color, lw: float, clip: bool,
     colour and weight rather than a nearby pair, because a divider that only
     nearly matches reads as a second, different thing.
 
+    It starts where the *cells* meet, not where the axes end.  Two cells of one
+    row touch at ``u = 0`` whichever layout is drawn -- without the diagonal
+    that is also the panel's near edge, so the two were the same number and the
+    difference never showed.  With the diagonal the panel reaches half a cell
+    further out, and a rule begun at the edge leaves that half cell unruled:
+    the line between two names starts in mid air instead of at the matrix.
+
     Below the tick labels, like the band: an axis draws its labels at zorder
     2.5, and a rule over one of them is a strike-through.
     """
     from matplotlib.collections import LineCollection
 
     target = ax.ax if hasattr(ax, "ax") else ax
-    x0, x1 = span
+    try:
+        lo, hi = target.get_xlim()
+        meet = (0.0 - float(lo)) / (float(hi) - float(lo))
+    except Exception:
+        meet = span[1] if span[0] < 0.0 else span[0]
+    x0, x1 = min(span[0], meet), max(span[1], meet)
     rules = LineCollection(
         [[(x0, k + 0.5), (x1, k + 0.5)] for k in range(int(n) - 1)],
         colors=color, linewidths=lw, zorder=0.6,
@@ -409,7 +495,7 @@ def _stripe_the_labels(ax, n: int, shaded, span, color, clip: bool) -> None:
         ax.axhspan(
             k - 0.5, k + 0.5, xmin=span[0], xmax=span[1],
             facecolor=color, edgecolor="none", linewidth=0.0,
-            zorder=0.5, clip_on=clip,
+            zorder=_TINT_ZORDER, clip_on=clip,
         )
 
 
@@ -464,7 +550,7 @@ def _glyph_vertices(kind: str, cx, cy, rho, scale: float, corners=None):
 
 
 def _glyph_patches(kind: str, cx, cy, rho, scale: float, sign: float,
-                   ellipse_scale: float = 1.4):
+                   ellipse_scale: float = 1.4, diamond: bool = False):
     """One matplotlib patch per drawn cell, in data coordinates.
 
     Only the round glyphs come through here; the square ones are built as bare
@@ -494,7 +580,22 @@ def _glyph_patches(kind: str, cx, cy, rho, scale: float, sign: float,
             # the box does not -- so at k = glyph.scale the widest one covers
             # 0.64 of the cell while a circle covers 0.9.  sqrt(2) is the
             # factor that makes the two agree, which is where 1.4 comes from.
+            #
+            # And it is the *cell's* diagonal, not the page's.  `ellipse` is
+            # the one glyph with a direction, and its direction means something
+            # about the two axes of the cell it sits in: turn the lattice 45
+            # degrees and leave the ellipse behind and every one of them is
+            # reporting the wrong pair.  The index map sends the cell's own
+            # frame through a +45 degree rotation (`j+1` goes to `(+1/2, +1/2)`
+            # and `i+1` to `(-1/2, +1/2)`), so the glyph turns with it.
+            #
+            # `side: right` negates u, which reflects rather than rotates and
+            # sends an angle A to 135 - A.  It needs no case of its own: the
+            # angle here is a constant +/-45, and 135 - A and A + 45 differ by
+            # 180 exactly when they differ at all -- and an ellipse's angle is
+            # read modulo 180.
             k = scale * ellipse_scale
+            lean = sign * 45.0 + (45.0 if diamond else 0.0)
             r = 0.0 if not np.isfinite(r) else float(np.clip(r, -1.0, 1.0))
             width = k * np.sqrt(max(1.0 + r, 0.0)) / np.sqrt(2.0)
             # |rho| = 1 collapses the minor axis to zero, which fills no
@@ -503,7 +604,7 @@ def _glyph_patches(kind: str, cx, cy, rho, scale: float, sign: float,
             # as a line, so the minor axis gets a hairline floor.
             height = max(k * np.sqrt(max(1.0 - r, 0.0)) / np.sqrt(2.0), 0.02 * k)
             patches.append(
-                Ellipse((x, y), width=width, height=height, angle=sign * 45.0)
+                Ellipse((x, y), width=width, height=height, angle=lean)
             )
         elif kind == "pie":
             # Clockwise from twelve o'clock, as read off the page.
@@ -721,14 +822,53 @@ def draw_corrplot(ax, **kwargs):
     if sig_level is not None and insig == "blank":
         drawn &= ~insignificant
 
+    # The diagonal, when it is in.  A self pair sits at `u = 0`, so anything
+    # built from an ordinary cell there hangs a quarter of a cell past the
+    # panel and prints over the names -- and everything on this figure except
+    # `_stripe_the_labels` is drawn well above the axis' own zorder of 2.5, so
+    # it prints *over* them, not under.  Every shape cut from a cell therefore
+    # takes the pentagon on the diagonal: the fill, the grid outline, and the
+    # tint.  See `_self_cell_vertices`.
+    self_cells = drawn & (index_x.astype(int) == index_y.astype(int))
+
+    def _with_self_cells(shapes, selection, closed_loop: bool, shape_scale=1.0):
+        """Swap the pentagon in wherever `shapes` covers a self pair.
+
+        `selection` is the mask over *all* cells that `shapes` was built from,
+        which is not the same mask each time -- the fill is drawn for `drawn`,
+        the tint for the shaded band, the grid for everything.
+        """
+        picked = self_cells[selection]
+        if not diamond or not np.any(picked):
+            return shapes
+        out = [np.asarray(shape) for shape in shapes]
+        pentagons = _self_cell_vertices(iy[selection & self_cells], side, shape_scale)
+        for slot, pentagon in zip(np.flatnonzero(picked), pentagons):
+            out[slot] = (
+                np.vstack([pentagon, pentagon[:1]]) if closed_loop else pentagon
+            )
+        return out
+
     label_span = _label_span(ax, side, label_column_mm) if diamond else None
 
     if diamond and edge_lwd > 0.0 and label_span is not None:
         # The column is a width in axes fractions; the outline is drawn in cell
-        # units, and the panel is `u_span` cells wide.
-        column_u = -label_span[0] * (n / 2.0) if side == "left" else (
-            (label_span[1] - 1.0) * (n / 2.0)
-        )
+        # units, so it is scaled by how many cells wide the panel is.  Read off
+        # the axes rather than worked out as `n / 2`: with the diagonal in, the
+        # panel is a quarter cell wider than that (see `diamond_extent`), and a
+        # rule scaled by the wrong span stops short of the names it is meant to
+        # close over -- by 4% of the column, which at thirteen variables is the
+        # last two letters of the longest name left hanging outside it.
+        lo, hi = float(min(ax.get_xlim())), float(max(ax.get_xlim()))
+        u_span = hi - lo
+        # ... and measured from the panel's own near edge, which the diagonal
+        # moves out to `u = -1/4`.  `_edge_rules` strikes the horizontal run
+        # from `-column_u` to `0`, so the near edge has to be added back in:
+        # left out, the rule stops a quarter cell short and the last letters of
+        # the longest name hang outside the box it is meant to close.
+        near_u = lo if side == "left" else -hi
+        column_u = (-label_span[0] if side == "left" else label_span[1] - 1.0)
+        column_u = column_u * u_span - near_u
         _edge_rules(ax, n, column_u, side, edge_color, edge_lwd, zorder + 40, clip)
     if diamond and grid_color and label_span is not None:
         _label_rules(ax, n, label_span, grid_color, _GRID_LWD, clip, zorder)
@@ -763,19 +903,25 @@ def draw_corrplot(ax, **kwargs):
         band = shaded[index_x.astype(int)] | shaded[index_y.astype(int)]
         band &= drawn
         if np.any(band):
+            # The tint is a background and keeps the plain cell, diagonal
+            # included: it has to reach the panel's edge or the band it carries
+            # from the name into the matrix comes apart there.  It can, because
+            # the panel buys the whole half cell -- which is also what stops it
+            # printing over the names, and that is a clearance, not a shape.
             cells = PolyCollection(
                 np.stack([ix[band], iy[band]], axis=1)[:, None, :]
                 + 0.5 * _DIAMOND_CORNERS[None, :, :],
                 closed=True, facecolors=stripe_color, edgecolors="none",
-                zorder=zorder - 20,
+                zorder=_TINT_ZORDER,
             )
             cells.set_clip_on(clip)
             ax.add_collection(cells)
         # The half cells beside the names, so the band reaches the matrix and
         # the edge it makes is straight enough for the rules to close against.
+        # The diagonal moves this, it does not remove it: see `_notch_vertices`.
         notches = PolyCollection(
-            _notch_vertices(n, side)[shaded], closed=True,
-            facecolors=stripe_color, edgecolors="none", zorder=zorder - 20,
+            _notch_vertices(n, side, diag)[shaded], closed=True,
+            facecolors=stripe_color, edgecolors="none", zorder=_TINT_ZORDER,
         )
         notches.set_clip_on(clip)
         ax.add_collection(notches)
@@ -790,9 +936,13 @@ def draw_corrplot(ax, **kwargs):
     else:
         if kind in _POLYGON_GLYPHS:
             artists = PolyCollection(
-                _glyph_vertices(
-                    kind, ix[drawn], iy[drawn], rho[drawn], scale,
-                    corners=_DIAMOND_CORNERS if diamond else _CORNERS,
+                _with_self_cells(
+                    _glyph_vertices(
+                        kind, ix[drawn], iy[drawn], rho[drawn], scale,
+                        corners=_DIAMOND_CORNERS if diamond else _CORNERS,
+                    ),
+                    drawn if kind in _FILLED_GLYPHS else np.zeros(ix.shape, dtype=bool),
+                    closed_loop=False, shape_scale=scale,
                 ),
                 closed=True,
             )
@@ -800,7 +950,7 @@ def draw_corrplot(ax, **kwargs):
             artists = PatchCollection(
                 _glyph_patches(
                     kind, ix[drawn], iy[drawn], rho[drawn], round_scale, sign,
-                    ellipse_scale=ellipse_scale,
+                    ellipse_scale=ellipse_scale, diamond=diamond,
                 ),
                 match_original=False,
             )
@@ -847,14 +997,27 @@ def draw_corrplot(ax, **kwargs):
     if kind == "shade":
         # The sign is already in the colour; the hatch is what survives a
         # greyscale print, which is the whole point of shade.
+        #
+        # It runs corner to corner of the cell, and *which* corners is the
+        # layout's business.  On the square card those are the diagonal ones,
+        # `(+/-1, +/-1) * half`.  On the diamond the same cell is turned 45
+        # degrees, so its corners are the ones straight up and straight across
+        # -- and a stroke still drawn to `(+/-1, +/-1)` reaches `half * sqrt2`
+        # where the cell only reaches `half / sqrt2`: twice too long, over the
+        # boundary and into the neighbour, on every cell of the figure.
+        step = 0.5 * scale
+        arm = (
+            [(0.0, step), (step, 0.0)] if diamond else [(step, step), (step, -step)]
+        )
         hatch = LineCollection(
             [
                 [
-                    (x - 0.5 * scale, y - sign * 0.5 * scale * np.sign(r)),
-                    (x + 0.5 * scale, y + sign * 0.5 * scale * np.sign(r)),
+                    (x - dx, y - sign * dy * np.sign(r)),
+                    (x + dx, y + sign * dy * np.sign(r)),
                 ]
                 for x, y, r in zip(ix[drawn], iy[drawn], rho[drawn])
                 if r != 0.0
+                for dx, dy in [arm[0] if r > 0 else arm[1]]
             ],
             colors="#FFFFFF",
             linewidths=0.4,
@@ -868,9 +1031,23 @@ def draw_corrplot(ax, **kwargs):
         # picture, a quarter of the paths, and at 100 variables that is 40,000
         # of them.  The outline has to be per cell rather than n+1 ruled lines
         # because a `triangle` selection leaves holes for the ruling to cross.
+        # The pentagon is a shape for glyphs that *fill* their cell.  Outlining
+        # it under a round one would be drawing a boundary the glyph does not
+        # keep: at `rho = 1` the circle on the diagonal overhangs it, and the
+        # flat backs line up into a grey rail down the edge of the matrix with
+        # the circles straddling it.  So there the diagonal simply carries no
+        # outline -- the matrix's own edge is already closed by `edge.lwd`.
+        ruled = (
+            np.ones(ix.shape, dtype=bool)
+            if not diamond or kind in _FILLED_GLYPHS
+            else ~self_cells
+        )
         grid = LineCollection(
-            np.stack([ix, iy], axis=1)[:, None, :]
-            + (_DIAMOND_LOOP if diamond else _CELL_LOOP)[None, :, :],
+            _with_self_cells(
+                np.stack([ix[ruled], iy[ruled]], axis=1)[:, None, :]
+                + (_DIAMOND_LOOP if diamond else _CELL_LOOP)[None, :, :],
+                ruled, closed_loop=True,
+            ),
             colors=grid_color, linewidths=_GRID_LWD, zorder=zorder - 10,
         )
         grid.set_clip_on(clip)

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/jarvisplot/cards/corrplot/diamond.json

@@ -496,7 +496,7 @@
     "Options": {
         "method": {"type": "enum", "values": ["circle", "square", "ellipse", "color", "shade", "pie", "number"], "default": "circle"},
         "type": {"type": "enum", "values": ["upper", "lower"], "default": "upper", "forbidden": ["full"]},
-        "diag": {"type": "boolean", "default": false},
+        "diag": {"type": "boolean", "default": true},
         "side": {"type": "enum", "values": ["left", "right"], "default": "right"},
         "stripe": {"type": "enum", "values": ["alternate", "none"], "default": "alternate", "false_alias": "none"},
         "order": {"type": "enum", "values": ["original", "AOE", "FPC", "hclust", "alphabet"], "default": "original"},
@@ -511,7 +511,7 @@
         "corrplot": {
             "method": "circle",
             "type": "upper",
-            "diag": false,
+            "diag": true,
             "glyph.scale": 0.9,
             "ellipse.scale": 1.4,
             "outline": "sign",

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/jarvisplot/core_runtime.py

@@ -895,8 +895,17 @@ def _prebuild_one(core, info: dict, card: Mapping) -> None:
     _enforce_corr_contract(info, contract, name)
 
     source = entry.get("source")
-    dts = (getattr(core, "dataset_registry", {}) or {}).get(
-        source if isinstance(source, str) else None
+    # A correlation layer may intentionally concatenate several root
+    # datasets.  The runtime already supports source lists; the prebuild only
+    # needs one member's cheap column metadata to solve the shared geometry.
+    # Use the first registered member (the input tables are required to carry
+    # the same schema), while leaving the complete source list for the actual
+    # correlation transform below.
+    registry = getattr(core, "dataset_registry", {}) or {}
+    source_names = [source] if isinstance(source, str) else list(source or [])
+    dts = next(
+        (registry.get(item) for item in source_names if isinstance(item, str) and registry.get(item) is not None),
+        None,
     )
     names = list(getattr(dts, "keys", None) or [])
     if not names:

{jarvisplot-2.1.1 → jarvisplot-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "JarvisPLOT"
-version = "2.1.1"
+version = "2.1.2"
 description = "Jarvis-PLOT: YAML-driven plotting engine"
 readme = "README.md"
 requires-python = ">=3.10"