scistackplot 0.1.56__tar.gz → 0.1.58__tar.gz

{scistackplot-0.1.56 → scistackplot-0.1.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scistackplot
-Version: 0.1.56
+Version: 0.1.58
 Summary: Spec-driven plotting for long-format scientific data — standalone, GUI-friendly
 Author: SciStack Contributors
 License-Expression: MIT
@@ -20,8 +20,8 @@ Requires-Python: >=3.10
 Requires-Dist: csv-stats>=0.5.0
 Requires-Dist: numpy>=1.21
 Requires-Dist: pandas>=1.5
-Requires-Dist: scicanonicalhash==0.1.56
-Requires-Dist: scistacklog==0.1.56
+Requires-Dist: scicanonicalhash==0.1.58
+Requires-Dist: scistacklog==0.1.58
 Provides-Extra: dev
 Requires-Dist: matplotlib>=3.6; extra == 'dev'
 Requires-Dist: plotly>=5.0; extra == 'dev'
@@ -101,7 +101,7 @@ shape, through one pure function:
 ```python
 from scistackplot import available_plots, default_plot, Shape
 
-available_plots(Shape.SCALAR, {"session": Role.GROUP})                          # scatter, strip, bar
+available_plots(Shape.SCALAR, {"session": Role.GROUP})                          # scatter, strip, bar, hbar
 available_plots(Shape.SCALAR, {"session": Role.GROUP, "trial": Role.COLLAPSE})  # + box, violin
 ```
 
@@ -209,6 +209,23 @@ datetime `x_measure` is drawn on a date axis. Log axes are ignored on both
 kinds. "Save data" adds the bars or the fits as a table. See
 `docs/claude/histogram-and-regression.md`.
 
+## Horizontal bars
+
+`PlotKind.HBAR` is the bar plot turned: the same bars, error bars, colours,
+grouping, Show sample, comparison and limits, with the categories down the
+left (first level at the top) and the values along the bottom.
+
+```python
+spec = PlotSpec(measures=["StepLength"], roles=..., groups=["limb", "session"],
+                kind=PlotKind.HBAR)
+```
+
+Nothing upstream of drawing changes — "x" is still the category axis and
+"y" the value axis, so `y_axis`, `style.y_label` and `style.log_y` apply to
+the bottom axis. Outer grouping layers become brackets at the left, and a
+faceted panel's name is the title under it. Difference bars are not drawn on
+it. See `docs/claude/horizontal-bar.md`.
+
 ## Save the data behind a figure
 
 The rows a plot is drawn from are available as a long table, so the

{scistackplot-0.1.56 → scistackplot-0.1.58}/README.md

@@ -60,7 +60,7 @@ shape, through one pure function:
 ```python
 from scistackplot import available_plots, default_plot, Shape
 
-available_plots(Shape.SCALAR, {"session": Role.GROUP})                          # scatter, strip, bar
+available_plots(Shape.SCALAR, {"session": Role.GROUP})                          # scatter, strip, bar, hbar
 available_plots(Shape.SCALAR, {"session": Role.GROUP, "trial": Role.COLLAPSE})  # + box, violin
 ```
 
@@ -168,6 +168,23 @@ datetime `x_measure` is drawn on a date axis. Log axes are ignored on both
 kinds. "Save data" adds the bars or the fits as a table. See
 `docs/claude/histogram-and-regression.md`.
 
+## Horizontal bars
+
+`PlotKind.HBAR` is the bar plot turned: the same bars, error bars, colours,
+grouping, Show sample, comparison and limits, with the categories down the
+left (first level at the top) and the values along the bottom.
+
+```python
+spec = PlotSpec(measures=["StepLength"], roles=..., groups=["limb", "session"],
+                kind=PlotKind.HBAR)
+```
+
+Nothing upstream of drawing changes — "x" is still the category axis and
+"y" the value axis, so `y_axis`, `style.y_label` and `style.log_y` apply to
+the bottom axis. Outer grouping layers become brackets at the left, and a
+faceted panel's name is the title under it. Difference bars are not drawn on
+it. See `docs/claude/horizontal-bar.md`.
+
 ## Save the data behind a figure
 
 The rows a plot is drawn from are available as a long table, so the

{scistackplot-0.1.56 → scistackplot-0.1.58}/src/scistackplot/__init__.py

@@ -137,6 +137,8 @@ from .spec import (
     PlotKind,
     PlotSpec,
     Role,
+    BAR_KINDS,
+    HORIZONTAL_KINDS,
     OVERLAY_KINDS,
     SCALAR_KINDS,
     Statistic,
@@ -148,6 +150,7 @@ from .spec import (
     VariantSet,
     YAxis,
     grid_shape_for,
+    is_horizontal,
 )
 from .bins import BinEdges, BinError, bin_edges
 from .fits import PanelFit, annotation_text
@@ -315,6 +318,9 @@ __all__ = [
     "VariantSet",
     "SCALAR_KINDS",
     "OVERLAY_KINDS",
+    "BAR_KINDS",
+    "HORIZONTAL_KINDS",
+    "is_horizontal",
     # 1-D -> scalar collapse
     "cell_collapses",
     "effective_shape",

{scistackplot-0.1.56 → scistackplot-0.1.58}/src/scistackplot/capability.py

@@ -38,12 +38,12 @@ from .roles import (
     sample_key,
 )
 from .shape import Shape
-from .spec import BUILTIN_KINDS, MAX_X_LAYERS, SCALAR_KINDS, PlotKind, PlotSpec, Role
+from .spec import BAR_KINDS, BUILTIN_KINDS, MAX_X_LAYERS, SCALAR_KINDS, PlotKind, PlotSpec, Role
 from .table import CODE_FACTOR_PREFIX, RUN_FACTOR_PREFIX, LongTable
 from .temporal import BAR_REASON, time_zone_summary
 
 #: Kinds that summarize several rows per x position into one mark.
-DISTRIBUTION_KINDS = (PlotKind.BOX, PlotKind.VIOLIN, PlotKind.BAR, PlotKind.BAND)
+DISTRIBUTION_KINDS = (PlotKind.BOX, PlotKind.VIOLIN, *BAR_KINDS, PlotKind.BAND)
 
 #: Kinds that cannot be drawn without a sample — ``roles.SAMPLE_NEEDING_KINDS``,
 #: read by ``roles.kind_requirement``, the one statement of what each kind
@@ -96,6 +96,7 @@ _ROLE_HINTS_BY_SHAPE: dict[Shape, dict[Role, str]] = {
 #: kind's (``roles.grouping_layers``); this is the reading, said out loud.
 _GROUPING_HINTS: dict[PlotKind, str] = {
     PlotKind.BAR: "One bar per combination — first entry innermost",
+    PlotKind.HBAR: "One bar per combination, top to bottom — first entry innermost",
     PlotKind.BOX: "One box per combination — first entry innermost",
     PlotKind.VIOLIN: "One violin per combination — first entry innermost",
     PlotKind.STRIP: "One point per combination — first entry innermost",
@@ -245,13 +246,14 @@ def available_plots(
                 PlotKind.SCATTER,
                 PlotKind.STRIP,
                 PlotKind.BAR,
+                PlotKind.HBAR,
                 PlotKind.SPAGHETTI,
                 PlotKind.BOX,
                 PlotKind.VIOLIN,
                 PlotKind.HISTOGRAM,
             )
             if kind_requirement(kind, Shape.SCALAR, roles, n_groups) is None
-            and not (temporal and kind is PlotKind.BAR)
+            and not (temporal and kind in BAR_KINDS)
         ]
 
     if shape is Shape.SERIES_1D:
@@ -334,7 +336,7 @@ def why_unavailable(
         if kind is PlotKind.HISTOGRAM:
             return HISTOGRAM_NO_X
         return "With an X variable, the kinds are scatter, line and regression; clear it for the others."
-    if temporal and kind is PlotKind.BAR:
+    if temporal and kind in BAR_KINDS:
         return BAR_REASON
     if shape is Shape.MATRIX_2D:
         return "2-D measures render as a heatmap."

{scistackplot-0.1.56 → scistackplot-0.1.58}/src/scistackplot/codegen.py

@@ -56,13 +56,16 @@ from .roles import (
 )
 from .shape import Shape
 from .spec import (
+    BAR_KINDS,
     CONTINUOUS_X_KINDS,
+    SUMMARY_KINDS,
     ErrorBand,
     FactorVariable,
     PlotKind,
     PlotSpec,
     Role,
     Statistic,
+    is_horizontal,
     value_spellings,
 )
 from .table import MISSING_LEVEL, LongTable
@@ -535,7 +538,7 @@ def _docstring(spec: PlotSpec, table: LongTable, roles: dict, y_plan: _YLimitPla
     steps = collapse_steps(spec, roles, table)
     if steps.all:
         chain = " -> ".join([*steps.pre, " x ".join(steps.sample)])
-        if spec.kind in (PlotKind.BAR, PlotKind.BAND):
+        if spec.kind in SUMMARY_KINDS:
             what = (
                 f"error bars: {spec.aggregate.error}"
                 f"{' (t-based)' if spec.aggregate.error is ErrorBand.CI95 else ''} across "
@@ -851,7 +854,7 @@ def _preamble(spec, table, roles, shape) -> list[str]:
         )
     if comparison is not None and not compared:
         lines.extend(_compare_lines(comparison, spec, kept, shape, index_column, overlay_drawn))
-    if steps.sample and spec.kind in (PlotKind.BAR, PlotKind.BAND):
+    if steps.sample and spec.kind in SUMMARY_KINDS:
         lines.append(
             f"# the sample: {' x '.join(steps.sample)} — seaborn's estimator and "
             f"errorbar run over its levels{' (pooled)' if len(steps.sample) > 1 else ''}"
@@ -1425,6 +1428,13 @@ def _sample_draw_lines(
     nested = _nested_x_order(spec, table, roles, shape)
     weight = sample_weight(spec.style)
     linestyle = "-" if join.join else "none"
+    # The screen (x, y) of a sample point: (position, value), or (value,
+    # position) on a horizontal kind (spec.is_horizontal).
+    xy = (
+        f"_part[{y!r}], _part[{_X_POSITION!r}]"
+        if is_horizontal(spec.kind)
+        else f"_part[{_X_POSITION!r}], _part[{y!r}]"
+    )
 
     spaghetti = spec.kind is PlotKind.SPAGHETTI
     line_layers = _line_layers(spec, table, roles, shape) if spaghetti else []
@@ -1546,14 +1556,14 @@ def _sample_draw_lines(
                     *(
                         [
                             "            if len(_part) > 1:",
-                            f"                _ax.plot(_part[{_X_POSITION!r}], _part[{y!r}], "
+                            f"                _ax.plot({xy}, "
                             f"color=_line_color, alpha={SAMPLE_ALPHA}, "
                             f"linewidth={weight.line_pt:.3f}, zorder=3)",
                         ]
                         if join.join
                         else []
                     ),
-                    f"            _ax.scatter(_part[{_X_POSITION!r}], _part[{y!r}], "
+                    f"            _ax.scatter({xy}, "
                     f"s={weight.marker_area:.3f}, color=_point_colors, alpha={SAMPLE_ALPHA}, "
                     f"edgecolors={SAMPLE_EDGE_COLOR!r}, linewidths={SAMPLE_EDGE_WIDTH:g}, "
                     + (
@@ -1569,7 +1579,7 @@ def _sample_draw_lines(
                 else []
             ),
             "        _ax.plot(",
-            f"            _part[{_X_POSITION!r}], _part[{y!r}],",
+            f"            {xy},",
             f"            linestyle={linestyle!r}, marker='o', markersize={weight.marker_pt:.3f},",
             f"            markeredgecolor={SAMPLE_EDGE_COLOR!r}, "
             f"markeredgewidth={SAMPLE_EDGE_WIDTH:g},",
@@ -1868,8 +1878,11 @@ def _alias_definition_lines(aliases: _ExportAliases) -> list[str]:
     ]
 
 
-def _alias_relabel_lines(aliases: _ExportAliases, x_categorical: bool) -> list[str]:
-    """Relabel the drawn x ticks and legend entries through ``_alias``.
+def _alias_relabel_lines(
+    aliases: _ExportAliases, x_categorical: bool, cat: str = "x"
+) -> list[str]:
+    """Relabel the drawn category ticks (on ``cat``, the screen axis they are
+    drawn on: y for a horizontal kind) and legend entries through ``_alias``.
 
     Runs after everything that draws or rebuilds text (the overlay rebuilds
     the legend) and before the fitted-tick replay, which then works on the
@@ -1891,8 +1904,8 @@ def _alias_relabel_lines(aliases: _ExportAliases, x_categorical: bool) -> list[s
                 f"_x_text = {text}",
                 "g.figure.canvas.draw()  # categorical tick labels exist once drawn",
                 "for _ax in g.axes.flat:",
-                "    _ax.set_xticks(_ax.get_xticks())",
-                "    _ax.set_xticklabels([_x_text(t.get_text()) for t in _ax.get_xticklabels()])",
+                f"    _ax.set_{cat}ticks(_ax.get_{cat}ticks())",
+                f"    _ax.set_{cat}ticklabels([_x_text(t.get_text()) for t in _ax.get_{cat}ticklabels()])",
             ]
         )
     dashes = aliases.aliased(*aliases.dash_layers)
@@ -1945,7 +1958,7 @@ def _uses_ci95(spec, shape) -> bool:
     """True when the plot call passes `errorbar=_ci95` (bar and band only)."""
     return (
         shape is not Shape.MATRIX_2D
-        and spec.kind in (PlotKind.BAR, PlotKind.BAND)
+        and spec.kind in SUMMARY_KINDS
         and spec.aggregate.error is ErrorBand.CI95
     )
 
@@ -1990,6 +2003,13 @@ def _plot_call(
         if kind is PlotKind.HISTOGRAM
         else [f"data=df", f"x={x_column!r}", f"y={spec.y_measure!r}"]
     )
+    if is_horizontal(kind):
+        # The same bars turned (spec.is_horizontal): the categories on y,
+        # the measure along x, and the orientation stated, not inferred.
+        args = [f"data=df", f"x={spec.y_measure!r}", f"y={x_column!r}", 'orient="h"']
+    # The screen axis each logical axis is drawn on: the CATEGORY axis and
+    # the VALUE axis (y limits, y scale, the y title) — swapped when horizontal.
+    cat, val = _screen_axes(spec)
     if color:
         args.append(f"hue={color!r}")
         if _color_level_count(spec, table, color) < 2:
@@ -2011,11 +2031,12 @@ def _plot_call(
     )
     errorbar = _SEABORN_ERRORBAR[spec.aggregate.error]
 
-    if kind in (PlotKind.BOX, PlotKind.VIOLIN, PlotKind.BAR, PlotKind.STRIP):
+    if kind in (PlotKind.BOX, PlotKind.VIOLIN, *BAR_KINDS, PlotKind.STRIP):
         seaborn_kind = {
             PlotKind.BOX: "box",
             PlotKind.VIOLIN: "violin",
             PlotKind.BAR: "bar",
+            PlotKind.HBAR: "bar",
             PlotKind.STRIP: "strip",
         }[kind]
         args.append(f'kind="{seaborn_kind}"')
@@ -2027,7 +2048,7 @@ def _plot_call(
             # mark there narrow and off-centre — the preview draws it on its
             # tick, full width (`render.mpl._draw_bars`).
             args.append("dodge=False")
-        if kind is PlotKind.BAR:
+        if kind in BAR_KINDS:
             args.append(f"estimator={estimator}")
             args.append(f"errorbar={errorbar}")
             # The export's error-bar ink and caps (paper.seaborn_err_kws);
@@ -2160,7 +2181,7 @@ def _plot_call(
         # argument" (found 2026-09-24 — every faceted per-panel catplot export
         # raised). relplot has no `sharey` and takes it through facet_kws.
         args.append(
-            "sharey=False" if call == "sns.catplot" else 'facet_kws={"sharey": False}'
+            f"share{val}=False" if call == "sns.catplot" else 'facet_kws={"sharey": False}'
         )
 
     aliases = _export_aliases(spec, table, roles, shape)
@@ -2185,9 +2206,9 @@ def _plot_call(
     if kind is PlotKind.REGRESSION:
         lines.extend(_fit_lines(spec, table, color, facets, aliases))
     if ylim is not None:
-        lines.append(f"g.set(ylim={(float(ylim[0]), float(ylim[1]))!r})")
+        lines.append(f"g.set({val}lim={(float(ylim[0]), float(ylim[1]))!r})")
     if y_plan.by_panel is not None:
-        lines.extend(_panel_ylim_lines(y_plan, facets))
+        lines.extend(_panel_ylim_lines(y_plan, facets, val))
     # The one owner (reduce.x_axis_title): no title on a nested axis, none
     # for the constant-x scaffolding column, the factor's display name
     # otherwise — exactly what the preview labels the axis.
@@ -2227,7 +2248,10 @@ def _plot_call(
         and table.measure(spec.x_measure).temporal
     ):
         x_label += zone_suffix
-    lines.append(f"g.set_axis_labels({x_label!r}, {y_label!r})")
+    # Positional (x title, y title) on the SCREEN: a horizontal kind's value
+    # title is the one along x.
+    titles = (y_label, x_label) if val == "x" else (x_label, y_label)
+    lines.append(f"g.set_axis_labels({titles[0]!r}, {titles[1]!r})")
     if facets:
         # Same rule as the preview (render.base.panel_y_title): the facet values
         # ARE the panel's y-axis title, and no caption sits above it. seaborn
@@ -2243,14 +2267,14 @@ def _plot_call(
             else "str(v) for v in reversed(_values)"
         )
         if overrides.titles or overrides.first_column:
-            lines.extend(['g.set_titles("")', *_panel_title_lines(overrides, shown)])
+            lines.extend(['g.set_titles("")', *_panel_title_lines(overrides, shown, val)])
         else:
             lines.extend(
                 [
                     'g.set_titles("")',
                     "for _key, _ax in g.axes_dict.items():",
                     "    _values = _key if isinstance(_key, tuple) else (_key,)",
-                    f'    _ax.set_ylabel(" · ".join({shown}))',
+                    f'    _ax.set_{val}label(" · ".join({shown}))',
                 ]
             )
     sizes = _export_sizes(style)
@@ -2273,14 +2297,16 @@ def _plot_call(
         and spec.x_measure in table.measure_names
         and table.measure(spec.x_measure).temporal
     )
-    if style.log_x and not log_inert and not temporal_x_measure:
+    # A horizontal kind's category axis is y and takes no log scale (as the
+    # preview, mpl._apply_horizontal_cosmetics); its value axis is x.
+    if style.log_x and not log_inert and not temporal_x_measure and cat == "x":
         lines.append('g.set(xscale="log")')
     if style.log_y and not log_inert:
-        lines.append('g.set(yscale="log")')
-    if y_plan.autoscaled and kind is PlotKind.BAR and not style.log_y:
-        lines.extend(_bar_autoscale_lines())
+        lines.append(f'g.set({val}scale="log")')
+    if y_plan.autoscaled and kind in BAR_KINDS and not style.log_y:
+        lines.extend(_bar_autoscale_lines(val))
     # Last of the y-range lines, so nothing after it rescales a pinned panel.
-    lines.extend(_panel_override_ylim_lines(overrides, facets))
+    lines.extend(_panel_override_ylim_lines(overrides, facets, val))
     # Difference bars set the final range of every panel they sit in (and
     # of every panel sharing that range), so they come after the pins.
     lines.extend(
@@ -2290,7 +2316,9 @@ def _plot_call(
     )
     if style.title:
         lines.append(f"g.figure.suptitle({style.title!r})")
-    lines.extend(_alias_relabel_lines(aliases, _x_is_categorical(spec, table, roles, shape)))
+    lines.extend(
+        _alias_relabel_lines(aliases, _x_is_categorical(spec, table, roles, shape), cat)
+    )
     # The frame, ticks and background the preview and render_matplotlib draw
     # (paper.py). Also undoes seaborn's default despine, which would export
     # an open frame beside a boxed preview.
@@ -2341,13 +2369,16 @@ def _fitted_tick_lines(spec, table: LongTable, roles, shape) -> list[str]:
                 wrapped[original[len(fit.prefix):]] = text
     rotated = fit.rotation != 0
     style = spec.style
+    # The category axis: y on a horizontal kind, whose labels are stacked
+    # and never rotated (ticklabels.STACKED_TICK_POLICY).
+    cat, _val = _screen_axes(spec)
     lines = [
-        f"# x tick labels as scistackplot fitted them at {style.width} x {style.height} in:"
+        f"# {cat} tick labels as scistackplot fitted them at {style.width} x {style.height} in:"
         f" {fit.describe()}"
         + (" (nested axis: rotation, font and every-k only)" if nested else ""),
         "g.figure.canvas.draw()  # categorical tick labels exist once drawn",
         "for _ax in g.axes.flat:",
-        "    _labels = [t.get_text() for t in _ax.get_xticklabels()]",
+        f"    _labels = [t.get_text() for t in _ax.get_{cat}ticklabels()]",
     ]
     if fit.prefix and not nested:
         lines.append(
@@ -2361,6 +2392,14 @@ def _fitted_tick_lines(spec, table: LongTable, roles, shape) -> list[str]:
             f"    _labels = [s if i % {fit.every} == 0 or i == len(_labels) - 1 else '' "
             "for i, s in enumerate(_labels)]"
         )
+    if cat == "y":
+        lines.extend(
+            [
+                "    _ax.set_yticks(_ax.get_yticks())",
+                f"    _ax.set_yticklabels(_labels, fontsize={fit.font_pt})",
+            ]
+        )
+        return lines
     lines.extend(
         [
             "    _ax.set_xticks(_ax.get_xticks())",
@@ -2429,7 +2468,7 @@ def _declared_levels(table: LongTable, name: str) -> list[str]:
 
 def _seaborn_call(spec, table, roles, shape) -> str:
     """Which seaborn function ``_plot_call`` draws with (heatmaps aside)."""
-    if spec.kind in (PlotKind.BOX, PlotKind.VIOLIN, PlotKind.BAR, PlotKind.STRIP):
+    if spec.kind in (PlotKind.BOX, PlotKind.VIOLIN, *BAR_KINDS, PlotKind.STRIP):
         return "sns.catplot"
     if spec.kind is PlotKind.SCATTER and _x_is_categorical(spec, table, roles, shape):
         return "sns.catplot"
@@ -2504,7 +2543,7 @@ def _heatmap_call(spec, table: LongTable) -> list[str]:
     ]
 
 
-def _bar_autoscale_lines() -> list[str]:
+def _bar_autoscale_lines(val: str = "y") -> list[str]:
     """Let an autoscaled bar axis pad below zero, as the preview's does.
 
     The preview's bar limits are ``min(low, 0)`` .. ``max(high, 0)`` padded by
@@ -2523,7 +2562,7 @@ def _bar_autoscale_lines() -> list[str]:
         "# otherwise pins an autoscaled bar axis to exactly 0).",
         "for _ax in g.axes.flat:",
         "    _ax.use_sticky_edges = False",
-        "    _ax.autoscale_view(scalex=False)",
+        f"    _ax.autoscale_view(scale{'y' if val == 'x' else 'x'}=False)",
     ]
 
 
@@ -2608,7 +2647,7 @@ def _panel_override_export(
 
 
 def _panel_override_ylim_lines(
-    overrides: _PanelOverrideExport, facets: list[str]
+    overrides: _PanelOverrideExport, facets: list[str], val: str = "y"
 ) -> list[str]:
     """Each overridden panel's own range, after every other y-range line.
 
@@ -2623,11 +2662,17 @@ def _panel_override_ylim_lines(
         "    _values = _key if isinstance(_key, tuple) else (_key,)",
         "    _pin = _panel_ylims.get(tuple(str(_v) for _v in reversed(_values)))",
         "    if _pin is not None:",
-        "        _ax.set_ylim(bottom=_pin[0], top=_pin[1])",
+        (
+            "        _ax.set_ylim(bottom=_pin[0], top=_pin[1])"
+            if val == "y"
+            else "        _ax.set_xlim(left=_pin[0], right=_pin[1])"
+        ),
     ]
 
 
-def _panel_title_lines(overrides: _PanelOverrideExport, shown: str) -> list[str]:
+def _panel_title_lines(
+    overrides: _PanelOverrideExport, shown: str, val: str = "y"
+) -> list[str]:
     """Each panel's y title with its override and the ``y_titles`` toggle.
 
     The text and the hide flag belong to the panel's facet values, so they are
@@ -2650,7 +2695,7 @@ def _panel_title_lines(overrides: _PanelOverrideExport, shown: str) -> list[str]
         f"        _hidden = {unset_hidden}",
         "    if _text is None:",
         f'        _text = " · ".join({shown})',
-        '    _ax.set_ylabel("" if _hidden else _text)',
+        f'    _ax.set_{val}label("" if _hidden else _text)',
     ]
 
 
@@ -2689,7 +2734,8 @@ def _difference_bar_export(
     would move every bar anyway: the code says the positions are fitted to
     this data.
     """
-    if not spec.difference_bars or shape is not Shape.SCALAR:
+    if not spec.difference_bars or shape is not Shape.SCALAR or is_horizontal(spec.kind):
+        # A horizontal kind draws none (diffbars.HORIZONTAL_REASON), as the preview.
         return None
     import matplotlib.pyplot as plt
 
@@ -2827,8 +2873,9 @@ def _difference_bar_lines(export: _DifferenceExport | None, style) -> list[str]:
     ]
 
 
-def _panel_ylim_lines(y_plan: _YLimitPlan, facets: list[str]) -> list[str]:
-    """Set each panel's y limits from the preview's per-facet table.
+def _panel_ylim_lines(y_plan: _YLimitPlan, facets: list[str], val: str = "y") -> list[str]:
+    """Set each panel's y limits from the preview's per-facet table (on
+    ``val``, the screen axis the values run along: x for a horizontal kind).
 
     ``axes_dict`` is keyed by the ``col`` value, or by ``(row, col)`` for two
     facets — the reverse of ``facets``' order, hence the ``reversed()`` (the
@@ -2848,7 +2895,7 @@ def _panel_ylim_lines(y_plan: _YLimitPlan, facets: list[str]) -> list[str]:
         "    _values = dict(",
         f"        zip({facets!r}, reversed(_key if isinstance(_key, tuple) else (_key,)))",
         "    )",
-        "    _ax.set_ylim(",
+        f"    _ax.set_{val}lim(",
         f"        _ylims.get(tuple(str(_values[_f]) for _f in {list(y_plan.panel_scope)!r}), "
         f"{fallback!r})",
         "    )",
@@ -3137,6 +3184,13 @@ def _x_expression(spec, table, roles, shape) -> str:
     return ticks[0] if ticks else _X_CONSTANT
 
 
+def _screen_axes(spec) -> tuple[str, str]:
+    """``(category axis, value axis)`` as the screen letters the generated
+    code addresses: ``("x", "y")``, or ``("y", "x")`` for a horizontal kind
+    (``spec.is_horizontal``, the one owner of orientation)."""
+    return ("y", "x") if is_horizontal(spec.kind) else ("x", "y")
+
+
 def _x_is_categorical(spec, table, roles, shape) -> bool:
     if spec.x_measure or shape is Shape.SERIES_1D or spec.kind in CONTINUOUS_X_KINDS:
         return False

{scistackplot-0.1.56 → scistackplot-0.1.58}/src/scistackplot/diffbars.py

@@ -168,6 +168,14 @@ DIFFERENCE_BAR_KINDS: tuple[str, ...] = (
     "spaghetti",
 )
 
+#: Why a horizontal kind (``spec.HORIZONTAL_KINDS``) carries no difference
+#: bars: they are stacked ABOVE the marks in points, a geometry with no
+#: horizontal counterpart yet (user, 2026-10-26: omit them for HBAR).
+HORIZONTAL_REASON = (
+    "Difference bars are drawn above vertical marks; use the vertical bar "
+    "plot for them."
+)
+
 
 def unavailable(spec: "PlotSpec", shape: "Shape", *, temporal: bool = False) -> str | None:
     """Why this figure cannot carry difference bars, or None.
@@ -178,7 +186,10 @@ def unavailable(spec: "PlotSpec", shape: "Shape", *, temporal: bool = False) ->
     answers it.
     """
     from .shape import Shape
+    from .spec import is_horizontal
 
+    if is_horizontal(spec.kind):
+        return HORIZONTAL_REASON
     if str(spec.kind) not in DIFFERENCE_BAR_KINDS:
         return (
             f"A {spec.kind} plot has no tick-by-tick marks to join; difference "

{scistackplot-0.1.56 → scistackplot-0.1.58}/src/scistackplot/reduce.py

@@ -79,6 +79,7 @@ from .spec import (
     PlotKind,
     PlotSpec,
     Role,
+    SUMMARY_KINDS,
     Statistic,
     grid_shape_for,
     value_spellings,
@@ -1354,14 +1355,14 @@ def _build_figure(
         overlay_frame: pd.DataFrame | None = None
         summarize_nested = (
             explode
-            and spec.kind in (PlotKind.BAND, PlotKind.BAR)
+            and spec.kind in SUMMARY_KINDS
             # A compared 1-D band/bar takes the exploded route: the baseline
             # is `compare`'s, over long rows, never restated over cells. The
             # transport stride then runs after the summary is built from the
             # compared rows (`downsample`), not inside the explode.
             and comparison is None
         )
-        if comparison is not None and explode and spec.kind in (PlotKind.BAND, PlotKind.BAR):
+        if comparison is not None and explode and spec.kind in SUMMARY_KINDS:
             Log.info(
                 "compare: 1-D %s summarised from exploded rows (the nested-cell "
                 "summary does not compare)",
@@ -2231,7 +2232,7 @@ def _panel_frame(
     out = out.dropna(subset=[Y])
 
     # --- summarize the sample into centre + error ------------------------
-    if spec.kind in (PlotKind.BAR, PlotKind.BAND):
+    if spec.kind in SUMMARY_KINDS:
         # Carry the nested axis's LAYER columns through the summary. They are a
         # function of the composed key, so grouping by them as well changes no
         # group — but without them `_summarize`'s `reset_index` returns three
@@ -2944,8 +2945,8 @@ def _encoding_for(
         x=X,
         y=Y,
         color=COLOR if color else None,
-        y_low=Y_LOW if kind in (PlotKind.BAR, PlotKind.BAND) else None,
-        y_high=Y_HIGH if kind in (PlotKind.BAR, PlotKind.BAND) else None,
+        y_low=Y_LOW if kind in SUMMARY_KINDS else None,
+        y_high=Y_HIGH if kind in SUMMARY_KINDS else None,
         series=SERIES if series else None,
         dash=DASH if has_dash else None,
     )

{scistackplot-0.1.56 → scistackplot-0.1.58}/src/scistackplot/render/base.py

@@ -27,7 +27,7 @@ from ..panels import (
 )
 from ..resolved import DASH_CYCLE, SAMPLE_COLOR, SAMPLE_LINE, RUN, SERIES, ResolvedPlot
 from ..roles import overlay_in_legend
-from ..spec import PlotKind
+from ..spec import BAR_KINDS, PlotKind, is_horizontal
 
 LAYER = "scistackplot"
 
@@ -227,6 +227,38 @@ def shows_y_labels(resolved: ResolvedPlot, row: int, col: int) -> bool:
     return is_leftmost(resolved, row, col)
 
 
+def shows_category_labels(resolved: ResolvedPlot, row: int, col: int) -> bool:
+    """Whether this cell labels the CATEGORY axis (logical x: its ticks, its
+    brackets, its title) — the one rule both renderers read, whichever way
+    the kind points. Vertical, that is the axis at the bottom
+    (:func:`shows_x_labels`); horizontal (``spec.is_horizontal``) it runs
+    down the left, labelled where nothing sits to the left
+    (:func:`is_leftmost`)."""
+    if is_horizontal(resolved.kind):
+        return is_leftmost(resolved, row, col)
+    return shows_x_labels(resolved, row, col)
+
+
+def axis_sides(resolved: ResolvedPlot) -> dict[str, str]:
+    """Which side of each panel the logical axes are drawn on —
+    ``{"x": "bottom", "y": "left"}``, or swapped for a horizontal kind. The
+    GUI says where its "X label" / "Y axis" controls land from this
+    (``layout.meta.axis_sides``), never from the kind."""
+    if is_horizontal(resolved.kind):
+        return {"x": "left", "y": "bottom"}
+    return {"x": "bottom", "y": "left"}
+
+
+def shows_value_labels(resolved: ResolvedPlot, row: int, col: int) -> bool:
+    """Whether this cell numbers the VALUE axis (logical y). Vertical:
+    :func:`shows_y_labels`. Horizontal: the same rule turned — nothing
+    directly below, unless the panels are on different scales, when every
+    panel keeps its numbers."""
+    if is_horizontal(resolved.kind):
+        return not shares_y_axis(resolved) or shows_x_labels(resolved, row, col)
+    return shows_y_labels(resolved, row, col)
+
+
 def is_leftmost(resolved: ResolvedPlot, row: int, col: int) -> bool:
     """Whether nothing sits directly to the left of this cell: the first
     column, including a panel in a partial wrapped row whose left cell is
@@ -295,7 +327,7 @@ def panel_override_meta(resolved: ResolvedPlot) -> dict:
     ``unmatched`` lists overrides for panels not in this figure (inert).
     """
     at_left = {
-        id(panel): shows_y_labels(resolved, panel.grid_row, panel.grid_col)
+        id(panel): shows_value_labels(resolved, panel.grid_row, panel.grid_col)
         for panel in resolved.panels
     }
     panels = []
@@ -693,7 +725,7 @@ def fill_alpha(kind: PlotKind, style) -> float | None:
     and its own half-transparent box fill, and the export drew every fill
     opaque.
     """
-    if kind is PlotKind.BAR:
+    if kind in BAR_KINDS:
         return style.alpha
     if kind is PlotKind.BOX:
         return BOX_FILL_ALPHA