scistackplot 0.1.38__tar.gz → 0.1.40__tar.gz

{scistackplot-0.1.38 → scistackplot-0.1.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scistackplot
-Version: 0.1.38
+Version: 0.1.40
 Summary: Spec-driven plotting for long-format scientific data — standalone, GUI-friendly
 Author: SciStack Contributors
 License-Expression: MIT
@@ -19,7 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: numpy>=1.21
 Requires-Dist: pandas>=1.5
-Requires-Dist: scistacklog==0.1.38
+Requires-Dist: scistacklog==0.1.40
 Provides-Extra: dev
 Requires-Dist: matplotlib>=3.6; extra == 'dev'
 Requires-Dist: plotly>=5.0; extra == 'dev'

{scistackplot-0.1.38 → scistackplot-0.1.40}/src/scistackplot/codegen.py

@@ -64,7 +64,7 @@ from .spec import (
 from .table import MISSING_LEVEL, LongTable
 from .paper import PAPER, figure_rc_params, paper_axes_code, seaborn_err_kws
 from .textsize import ResolvedSizes, resolve_sizes
-from .weights import sample_weight, spaghetti_weight
+from .weights import SAMPLE_EDGE_WIDTH, sample_weight, spaghetti_weight
 from .ylimits import GLOBAL_KEY, pinned_ends
 from .variants import (
     LATEST,
@@ -1309,7 +1309,7 @@ def _sample_draw_lines(
                     ),
                     f"            _ax.scatter(_part[{_X_POSITION!r}], _part[{y!r}], "
                     f"s={weight.marker_area:.3f}, color=_point_colors, alpha={SAMPLE_ALPHA}, "
-                    f"edgecolors={SAMPLE_EDGE_COLOR!r}, linewidths=0.5, "
+                    f"edgecolors={SAMPLE_EDGE_COLOR!r}, linewidths={SAMPLE_EDGE_WIDTH:g}, "
                     + (
                         # Over the line, and marked as part of its run
                         # (render.base.SAMPLE_LINE_POINTS_GID), as the preview.
@@ -1325,7 +1325,8 @@ def _sample_draw_lines(
             "        _ax.plot(",
             f"            _part[{_X_POSITION!r}], _part[{y!r}],",
             f"            linestyle={linestyle!r}, marker='o', markersize={weight.marker_pt:.3f},",
-            f"            markeredgecolor={SAMPLE_EDGE_COLOR!r}, markeredgewidth=0.5,",
+            f"            markeredgecolor={SAMPLE_EDGE_COLOR!r}, "
+            f"markeredgewidth={SAMPLE_EDGE_WIDTH:g},",
             f"            color={paint}, alpha={SAMPLE_ALPHA}, "
             f"linewidth={weight.line_pt:.3f}, zorder=3,",
             "        )",
@@ -1363,7 +1364,7 @@ def _sample_legend_lines(
         "    for _lvl in _sample_levels:",
         "        _entries[_lvl] = Line2D([], [], color=_sample_palette[_lvl], "
         f"linestyle={linestyle!r}, marker='o', markeredgecolor={SAMPLE_EDGE_COLOR!r}, "
-        "markeredgewidth=0.5)",
+        f"markeredgewidth={SAMPLE_EDGE_WIDTH:g})",
         f"    g.add_legend(legend_data=_entries, title={title!r})",
     ]
 

{scistackplot-0.1.38 → scistackplot-0.1.40}/src/scistackplot/diffbars.py

@@ -428,8 +428,15 @@ def log_figure(resolved: "ResolvedPlot") -> None:
 # bars need depends on ``u``, which depends on the top, so the top is found
 # by iterating to a fixed point (:func:`place_group`).
 
-#: Clearance between whatever is below and a bar's line (or a leg's foot).
+#: Clearance between whatever is below and a bar's line.
 GAP_PT = 3.0
+#: Clearance between the data under an end and that leg's foot (2026-10-16:
+#: at GAP_PT the leg read as touching the data). Larger than GAP_PT: the line
+#: only spans, a leg points AT a mark.
+FOOT_GAP_PT = 6.0
+#: The shortest a leg is drawn, from its foot to the line (2026-10-16:
+#: before, the leg over the taller end was half a line width — no leg).
+MIN_LEG_PT = 5.0
 #: A bar's line width.
 LINE_PT = 1.0
 #: Between the line and the bottom of its label's box.
@@ -560,6 +567,8 @@ class BarSizes:
     #: The label's font size (``TextSizes.differences``).
     label_font_pt: float
     gap_pt: float = GAP_PT
+    foot_gap_pt: float = FOOT_GAP_PT
+    min_leg_pt: float = MIN_LEG_PT
     line_pt: float = LINE_PT
     label_gap_pt: float = LABEL_GAP_PT
     pad_pt: float = PAD_PT
@@ -703,19 +712,31 @@ def _place_once(
             floors.append(under_label - above_line)
         floor = max(floors) if floors else bottom
         y = floor + (sizes.gap_pt + half_line) / per_y
+
+        # Each leg stops ``foot_gap_pt`` above what is under its end, so it
+        # never reads as touching the data. The line rises until every leg is
+        # at least ``min_leg_pt`` long (the end under the span's highest mark,
+        # or a lower bar's level, would otherwise get no visible leg). Both in
+        # points, so neither changes with the y range.
+        min_leg = sizes.min_leg_pt / per_y
+        foot_gap = sizes.foot_gap_pt / per_y
+        # A leg is a line: what it must clear is under its whole width, not
+        # its centre (a marker 3.01 pt off a leg of half-width 0.5 pt with a
+        # 3.5 pt reach was missed at the centre and touched, 2026-10-16).
+        half_leg = half_line / per_x
+        unders = [height(x - half_leg, x + half_leg) for x in (left, right)]
+        raised = [under + foot_gap + min_leg for under in unders if under is not None]
+        if raised:
+            y = max(y, max(raised))
+        feet = [
+            under + foot_gap
+            if under is not None
+            else max(bottom, y - max(2 * sizes.gap_pt / per_y, min_leg))
+            for under in unders
+        ]
         label_bottom = y + above_line
         label_top = label_bottom + height_pt / per_y
 
-        feet = []
-        for x in (left, right):
-            under = height(x, x)
-            foot = (
-                min(y, under + sizes.gap_pt / per_y)
-                if under is not None
-                else max(bottom, y - 2 * sizes.gap_pt / per_y)
-            )
-            feet.append(foot)
-
         if pinned and label_top > top:
             unfit.append(item)
             continue
@@ -842,6 +863,59 @@ def place_group(
     )
 
 
+def leg_lengths_pt(
+    result: GroupPlacement, frames: list[PanelFrame], log: bool = False
+) -> list[float]:
+    """Every placed leg's length in points on the final axis — what
+    ``MIN_LEG_PT`` guarantees (unless a leg reaches the axis bottom)."""
+    axis = (lambda v: math.log10(v)) if log else (lambda v: v)
+    bottom, top = axis(result.limits[0]), axis(result.limits[1])
+    lengths = []
+    for placed, frame in zip(result.placed, frames):
+        per_y = frame.height_pt / (top - bottom) if top > bottom else 0.0
+        for bar in placed:
+            for foot in (bar.left_foot, bar.right_foot):
+                lengths.append((axis(bar.y) - axis(foot)) * per_y)
+    return lengths
+
+
+def foot_clearances_pt(
+    result: GroupPlacement, problems: list[PanelProblem], log: bool = False
+) -> list[float]:
+    """Every placed foot's height above the data under it, in points on the
+    final axis — what ``FOOT_GAP_PT`` guarantees. *problems* hold the data's
+    obstacles only (no bars), so a foot resting over a lower bar reports
+    its height above the data, which is more than the gap. A foot with no
+    data under it is left out."""
+    axis = (lambda v: math.log10(v)) if log else (lambda v: v)
+    bottom, top = axis(result.limits[0]), axis(result.limits[1])
+    clearances = []
+    for placed, problem in zip(result.placed, problems):
+        if top <= bottom:
+            continue
+        per_y = problem.frame.height_pt / (top - bottom)
+        per_x = problem.frame.per_unit_x
+        obstacles = problem.obstacles.to_axis(log)
+        half_leg = (LINE_PT / 2.0) / per_x
+        for bar in placed:
+            for x, foot in ((bar.left, bar.left_foot), (bar.right, bar.right_foot)):
+                under = obstacles.top_over(
+                    x - half_leg, x + half_leg, per_unit_y=per_y, per_unit_x=per_x
+                )
+                if under is not None:
+                    clearances.append((axis(foot) - under) * per_y)
+    return clearances
+
+
+def _legs_note(result: GroupPlacement, problems: list[PanelProblem], log: bool) -> str:
+    lengths = leg_lengths_pt(result, [p.frame for p in problems], log)
+    clearances = foot_clearances_pt(result, problems, log)
+    note = f", shortest leg {min(lengths):.1f} pt" if lengths else ""
+    if clearances:
+        note += f", lowest foot {min(clearances):.1f} pt above the data"
+    return note
+
+
 # ---------------------------------------------------------------------------
 # A resolved figure -> problems
 
@@ -859,9 +933,10 @@ def panel_obstacles(resolved: "ResolvedPlot", panel: "Panel") -> Obstacles:
       ``spanmode: "hard"`` stop at the data); a box's flier adds its radius;
     - strip: every point, jittered ``±STRIP_JITTER``, plus the marker radius;
     - scatter: every point plus the marker radius;
-    - spaghetti: every point at its line's offset plus the marker radius,
+    - spaghetti: every point at its line's offset plus the marker's reach
+      (radius + half its edge stroke, ``weights.ResolvedWeight.marker_reach_pt``),
       and every segment of every run plus half the line width;
-    - overlay: every point at ``sample_positions`` plus its radius, and the
+    - overlay: every point at ``sample_positions`` plus its reach, and the
       joining segments when joined.
     """
     from .render.base import (
@@ -918,7 +993,7 @@ def panel_obstacles(resolved: "ResolvedPlot", panel: "Panel") -> Obstacles:
                 xs, _ = x_positions(run[encoding.x], resolved)
                 xs = xs + offsets.get(str(series_id), 0.0)
                 ys = pd.to_numeric(run[encoding.y], errors="coerce").to_numpy(dtype=float)
-                rows.extend(_polyline(xs, ys, weight.marker_pt / 2.0, weight.line_pt / 2.0, True))
+                rows.extend(_polyline(xs, ys, weight.marker_reach_pt, weight.line_pt / 2.0, True))
         else:  # scatter, and anything else drawn as points
             rows.extend((p, p, v, v, marker_radius) for p, v in zip(positions, values))
 
@@ -929,7 +1004,7 @@ def panel_obstacles(resolved: "ResolvedPlot", panel: "Panel") -> Obstacles:
             xs = sample_positions(run.rows, resolved, run.identity)
             ys = pd.to_numeric(run.rows[encoding.y], errors="coerce").to_numpy(dtype=float)
             joined = resolved.sample_join and len(run.rows) > 1
-            rows.extend(_polyline(xs, ys, weight.marker_pt / 2.0, weight.line_pt / 2.0, joined))
+            rows.extend(_polyline(xs, ys, weight.marker_reach_pt, weight.line_pt / 2.0, joined))
     return Obstacles.build(rows)
 
 
@@ -1106,7 +1181,9 @@ def place_figure(
         notes.append(
             f"{names}: {sum(len(p) for p in result.placed)} placed, {n_unfit} unfit, "
             f"top {shared[1]:.6g} -> {result.limits[1]:.6g} "
-            f"({result.iterations} iteration(s), bars {result.bar_fraction:.0%} of the height)"
+            f"({result.iterations} iteration(s), bars {result.bar_fraction:.0%} of the height"
+            + _legs_note(result, problems, log)
+            + ")"
             + (f", raised to at least {top_floor:.6g} for other figures" if top_floor is not None else "")
         )
         Log.debug(

{scistackplot-0.1.38 → scistackplot-0.1.40}/src/scistackplot/render/mpl.py

@@ -25,7 +25,7 @@ from ..spec import PlotKind
 from ..table import natural_sort_key
 from ..paper import PAPER, apply_paper_axes, describe_paper, figure_rc_params
 from ..textsize import ResolvedSizes, sizes_for
-from ..weights import describe_weights, sample_weight, spaghetti_weight
+from ..weights import SAMPLE_EDGE_WIDTH, describe_weights, sample_weight, spaghetti_weight
 from ..ticklabels import (
     BRACKET_POLICY,
     TICK_POLICY,
@@ -396,6 +396,7 @@ def _draw_spaghetti(ax, frame, resolved) -> None:
                 # A diameter in pt (weights.spaghetti_weight): at 1x the same
                 # visual size as the scatter kinds' `s` area.
                 markersize=weight.marker_pt,
+                markeredgewidth=weight.marker_edge_pt,
                 label=(
                     resolved.text.color_level(level)
                     if (level is not None and position == 0)
@@ -629,7 +630,7 @@ def _draw_sample(ax, panel, resolved: ResolvedPlot) -> tuple[int, int]:
                 marker="o",
                 markersize=weight.marker_pt,
                 markeredgecolor=SAMPLE_EDGE_COLOR,
-                markeredgewidth=0.5,
+                markeredgewidth=weight.marker_edge_pt,
                 zorder=3,
             )
             continue
@@ -651,7 +652,7 @@ def _draw_sample(ax, panel, resolved: ResolvedPlot) -> tuple[int, int]:
             color=[run.point_colors[i] for i in order],
             alpha=SAMPLE_ALPHA,
             edgecolors=SAMPLE_EDGE_COLOR,
-            linewidths=0.5,
+            linewidths=weight.marker_edge_pt,
             zorder=3.1,
             gid=SAMPLE_LINE_POINTS_GID,
         )
@@ -663,7 +664,7 @@ def _draw_sample(ax, panel, resolved: ResolvedPlot) -> tuple[int, int]:
             color=color,
             alpha=SAMPLE_ALPHA,
             edgecolors=SAMPLE_EDGE_COLOR,
-            linewidths=0.5,
+            linewidths=weight.marker_edge_pt,
             zorder=3,
         )
     artists += len(lone)
@@ -687,7 +688,7 @@ def _sample_legend_handles(ax, resolved: ResolvedPlot) -> None:
             linestyle="-" if resolved.sample_join else "none",
             marker="o",
             markeredgecolor=SAMPLE_EDGE_COLOR,
-            markeredgewidth=0.5,
+            markeredgewidth=SAMPLE_EDGE_WIDTH,
             label=resolved.text.sample_level(level),
         )
 
@@ -1900,6 +1901,14 @@ def layout_decisions(
     "width_in", "height_in"}``. The plotly preview
     applies these rather than estimating text of its own, so what the preview
     shows and what the file gets cannot come from two different rules.
+
+    One layout, not two: the auto text size search already lays the figure
+    out at every reference it tries, and a layout depends on the auto result
+    only through its ``reference`` (``textsize.sizes_for``). So the trial at
+    the chosen reference IS the final layout, and its decisions are kept
+    rather than drawn again (scidb.log 2026-10-16: the redraw was ~0.4 s of
+    every ~0.85 s next/previous click). A custom kind's trial skips the
+    user's function (``custom.measuring``), so it is always drawn again.
     """
     import matplotlib.pyplot as plt
 
@@ -1911,37 +1920,87 @@ def layout_decisions(
     with _one_figure_at_a_time("layout_decisions"), Log.timer(
         "layout_decisions", layer=LAYER, extra=f"{width:.2f}x{height:.2f}in"
     ):
+        # {reference: decisions} of each auto-size trial laid out here.
+        trials: dict[float, dict] = {}
+
+        def measure(candidate: ResolvedPlot):
+            decisions: dict = {}
+            report = _layout_report(candidate, decisions_out=decisions)
+            trials[candidate.auto_text.reference] = decisions
+            return report
+
+        reusable = resolved.kind is not PlotKind.CUSTOM
         # Auto text is chosen at the size being decided (the pane's, in Fit
         # pane), keyed on the caller's object so the preview's later
         # render_plotly and a Save of the same resolve reuse it.
-        target = at_size(settle(resolved, width_in=width, height_in=height), width, height)
-        fig = render(target)
-        try:
-            fits = getattr(fig, LABEL_FIT_ATTR, None) or {}
-            axis_text = getattr(fig, AXIS_TEXT_ATTR, None) or ()
-            return {
-                "ticks": fits.get("ticks"),
-                "brackets": fits.get("brackets"),
-                "bracket_geometry": fits.get("bracket_geometry"),
-                "grid_reach": getattr(fig, GRID_REACH_ATTR, None),
-                # tuple[base.AxisText, ...]: the tick values/labels and title
-                # distance the export drew, which the preview copies so the
-                # y text it puts in a column gap is the text measured for it,
-                # and a numeric x axis shows the ticks the auto size judged.
-                "y_axes": tuple(a for a in axis_text if a.axis == "y"),
-                "x_axes": tuple(a for a in axis_text if a.axis == "x"),
-                "legend": getattr(fig, LEGEND_ATTR, None),
-                # diffbars.FigurePlacement, or None: the preview draws these
-                # bars and ranges rather than placing its own.
-                "difference_bars": getattr(fig, DIFF_BARS_ATTR, None),
-                # autosize.AutoTextSize, or None when the size is fixed: the
-                # preview draws at these sizes rather than searching again.
-                "auto_text": target.auto_text,
-                "width_in": width,
-                "height_in": height,
-            }
-        finally:
-            plt.close(fig)
+        target = at_size(
+            settle(
+                resolved,
+                width_in=width,
+                height_in=height,
+                measure=measure if reusable else None,
+            ),
+            width,
+            height,
+        )
+        auto = target.auto_text
+        decisions = trials.get(auto.reference) if auto is not None else None
+        if decisions is not None:
+            Log.info(
+                "layout_decisions%s: kept the %gpt auto-size trial's layout "
+                "(%d trial(s)); no second matplotlib layout",
+                f" ({resolved.figure_label})" if resolved.figure_label else "",
+                auto.reference,
+                len(trials),
+                layer=LAYER,
+            )
+        else:
+            # Why a full draw: a fixed text size, a memo hit (the search did
+            # not run here), or a custom kind.
+            Log.debug(
+                "layout_decisions: drawing (%s)",
+                "custom kind" if not reusable
+                else "fixed text size" if auto is None
+                else "auto size reused, no trial here",
+                layer=LAYER,
+            )
+            fig = render(target)
+            try:
+                decisions = _figure_decisions(fig)
+            finally:
+                plt.close(fig)
+        return {
+            **decisions,
+            # autosize.AutoTextSize, or None when the size is fixed: the
+            # preview draws at these sizes rather than searching again.
+            "auto_text": auto,
+            "width_in": width,
+            "height_in": height,
+        }
+
+
+def _figure_decisions(fig) -> dict:
+    """What a drawn export decided, as ``layout_decisions`` returns it (less
+    the size and ``auto_text``). The one reader of the figure's records, for
+    both the final draw and a kept auto-size trial."""
+    fits = getattr(fig, LABEL_FIT_ATTR, None) or {}
+    axis_text = getattr(fig, AXIS_TEXT_ATTR, None) or ()
+    return {
+        "ticks": fits.get("ticks"),
+        "brackets": fits.get("brackets"),
+        "bracket_geometry": fits.get("bracket_geometry"),
+        "grid_reach": getattr(fig, GRID_REACH_ATTR, None),
+        # tuple[base.AxisText, ...]: the tick values/labels and title
+        # distance the export drew, which the preview copies so the
+        # y text it puts in a column gap is the text measured for it,
+        # and a numeric x axis shows the ticks the auto size judged.
+        "y_axes": tuple(a for a in axis_text if a.axis == "y"),
+        "x_axes": tuple(a for a in axis_text if a.axis == "x"),
+        "legend": getattr(fig, LEGEND_ATTR, None),
+        # diffbars.FigurePlacement, or None: the preview draws these
+        # bars and ranges rather than placing its own.
+        "difference_bars": getattr(fig, DIFF_BARS_ATTR, None),
+    }
 
 
 def layout_report(resolved: ResolvedPlot):
@@ -1953,7 +2012,10 @@ def layout_report(resolved: ResolvedPlot):
         return _layout_report(resolved)
 
 
-def _layout_report(resolved: ResolvedPlot):
+def _layout_report(resolved: ResolvedPlot, *, decisions_out: dict | None = None):
+    """``layout_report``'s body. ``decisions_out``, when given, is filled
+    with the figure's ``_figure_decisions`` before it closes, so a trial at
+    the chosen reference serves as the final layout too."""
     import matplotlib.pyplot as plt
 
     from ..autosize import LayoutReport
@@ -1964,6 +2026,8 @@ def _layout_report(resolved: ResolvedPlot):
     with measuring():
         fig = render(resolved)
     try:
+        if decisions_out is not None:
+            decisions_out.update(_figure_decisions(fig))
         fits = getattr(fig, LABEL_FIT_ATTR, None) or {}
         ticks, brackets = fits.get("ticks"), fits.get("brackets")
         legend = getattr(fig, LEGEND_ATTR, None) or {}

{scistackplot-0.1.38 → scistackplot-0.1.40}/src/scistackplot/render/plotly_.py

@@ -43,7 +43,7 @@ from ..diffbars import (
     sibling_floors,
 )
 from ..textsize import sizes_for
-from ..weights import mark_weights_meta, sample_weight, spaghetti_weight
+from ..weights import SAMPLE_EDGE_WIDTH, mark_weights_meta, sample_weight, spaghetti_weight
 from ..xaxis import LEAF_SEPARATOR
 from .base import (
     MARK_OFFSET_GROUP,
@@ -758,7 +758,7 @@ def _sample_traces(
                     if run.uniform
                     else [run.point_colors[i] for i in order],
                     "size": weight.marker_px,
-                    "line": {"color": SAMPLE_EDGE_COLOR, "width": 0.5},
+                    "line": {"color": SAMPLE_EDGE_COLOR, "width": SAMPLE_EDGE_WIDTH},
                 },
                 "line": {"color": run.line_color, "width": weight.line_pt},
                 "opacity": SAMPLE_ALPHA,

{scistackplot-0.1.38 → scistackplot-0.1.40}/src/scistackplot/weights.py

@@ -29,6 +29,14 @@ SAMPLE_MARKER_FRACTION = 0.45
 SAMPLE_LINE_WIDTH = 1.0
 #: A spaghetti's own polylines at 1x.
 SPAGHETTI_LINE_WIDTH = 1.2
+#: The edge stroke round a marker, in points, at every weight (it outlines;
+#: it does not scale). It widens the marker by half its width on each side,
+#: which ``diffbars.panel_obstacles`` must count (2026-10-16: a leg touched a
+#: spaghetti marker the obstacle model thought it cleared).
+SAMPLE_EDGE_WIDTH = 0.5
+#: matplotlib's ``lines.markeredgewidth`` default, which the spaghetti drew
+#: before it was stated here.
+SPAGHETTI_EDGE_WIDTH = 1.0
 #: The plotly preview draws a marker of ``d`` pt at ``d x 4/3`` px — the
 #: 96/72 pt-to-px ratio. Pinned so 1x reproduces the preview as it was (8 px
 #: markers where matplotlib draws 6 pt). Lines are 1 pt = 1 px, as before.
@@ -54,6 +62,13 @@ class ResolvedWeight:
     marker_pt: float
     #: Line width in points (and px in the preview).
     line_pt: float
+    #: The marker's edge stroke in points (``markeredgewidth``).
+    marker_edge_pt: float
+
+    @property
+    def marker_reach_pt(self) -> float:
+        """How far a marker reaches from its centre, edge included."""
+        return self.marker_pt / 2.0 + self.marker_edge_pt / 2.0
 
     @property
     def marker_area(self) -> float:
@@ -83,6 +98,7 @@ def sample_weight(style: StyleOptions) -> ResolvedWeight:
         weight=w,
         marker_pt=math.sqrt(style.marker_size * SAMPLE_MARKER_FRACTION) * w,
         line_pt=SAMPLE_LINE_WIDTH * w,
+        marker_edge_pt=SAMPLE_EDGE_WIDTH,
     )
 
 
@@ -94,6 +110,7 @@ def spaghetti_weight(style: StyleOptions) -> ResolvedWeight:
         weight=w,
         marker_pt=math.sqrt(style.marker_size) * w,
         line_pt=SPAGHETTI_LINE_WIDTH * w,
+        marker_edge_pt=SPAGHETTI_EDGE_WIDTH,
     )