ultraplot 2.1.9__tar.gz → 2.2.0__tar.gz

{ultraplot-2.1.9 → ultraplot-2.2.0}/.github/workflows/publish-pypi.yml

@@ -3,8 +3,7 @@ name: Publish to PyPI
 on:
   pull_request:
   push:
-    tags:
-      - "v*"
+    tags: ["v*"]
 
 concurrency:
   group: publish-pypi-${{ github.sha }}

{ultraplot-2.1.9/ultraplot.egg-info → ultraplot-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultraplot
-Version: 2.1.9
+Version: 2.2.0
 Summary: A succinct matplotlib wrapper for making beautiful, publication-quality graphics.
 Author-email: Casper van Elteren <caspervanelteren@gmail.com>, Luke Davis <lukelbd@gmail.com>
 Maintainer-email: Casper van Elteren <caspervanelteren@gmail.com>, "Matthew R. Becker" <becker.mr@gmail.com>
@@ -29,7 +29,7 @@ Provides-Extra: docs
 Requires-Dist: jupyter; extra == "docs"
 Requires-Dist: jupytext; extra == "docs"
 Requires-Dist: lxml-html-clean; extra == "docs"
-Requires-Dist: m2r2; extra == "docs"
+Requires-Dist: markdown; extra == "docs"
 Requires-Dist: mpltern; extra == "docs"
 Requires-Dist: nbsphinx; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"

ultraplot-2.2.0/docs/_scripts/fetch_releases.py

@@ -0,0 +1,154 @@
+"""
+Dynamically build the "What's new?" page from the GitHub releases feed.
+
+The release notes on GitHub are written in Markdown and frequently mix raw
+HTML (``<details><summary>`` blocks wrapping fenced code samples). The
+previous implementation converted the body to RST via ``m2r2``, which left
+the inner Markdown code fences inside ``.. raw:: html`` directives — Sphinx
+then rendered them as literal text. This module instead converts each
+release body to HTML (so fences become ``<pre><code>`` elements) and emits
+a single ``.. raw:: html`` block per release wrapped in a styling hook
+``div.uplt-whats-new-release-body``.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Iterable
+
+import markdown
+import requests
+
+GITHUB_REPO = "ultraplot/ultraplot"
+OUTPUT_RST = Path("whats_new.rst")
+GITHUB_API_URL = f"https://api.github.com/repos/{GITHUB_REPO}/releases"
+
+# Markdown extensions: fenced code (for ```python blocks), tables, attribute
+# lists for class hooks, and md_in_html so block-level HTML such as
+# ``<details>`` correctly contains parsed Markdown children.
+_MD_EXTENSIONS = ("fenced_code", "tables", "attr_list", "md_in_html")
+
+# Strip the trailing "by @user in PR_URL" attribution that GitHub auto-adds
+# to release notes. Keep the PR link in parentheses so credit/traceability
+# remains while removing the contributor handles from rendered output.
+# GitHub author handles can include ``[bot]`` suffixes (``@dependabot[bot]``,
+# ``@pre-commit-ci[bot]``); ``\w`` alone misses the brackets.
+_PR_ATTRIBUTION = re.compile(
+    r" by @[\w.\-]+(?:\[bot\])? in (https://github\.com/[^\s]+)"
+)
+
+# Match an ATX heading line, tolerating up-to-3 leading spaces. Authors
+# occasionally indent whole sections by two spaces in the GitHub release
+# editor (e.g. v2.0.1's "### Layout, Rendering, and Geo Improvements"),
+# which python-markdown then parses as a paragraph rather than a heading.
+# We capture the ``#`` run so we can both strip the indent and downgrade
+# one level — the page already provides the H1 ("What's new?") and each
+# release contributes a per-release RST H2, so body headings start at H2.
+_ATX_HEADING = re.compile(r"^[ ]{0,3}(#{1,5})(?=\s)", flags=re.MULTILINE)
+
+
+def _strip_pr_attribution(text: str) -> str:
+    return _PR_ATTRIBUTION.sub(r" (\1)", text)
+
+
+def _downgrade_headings(text: str) -> str:
+    """Demote every Markdown ATX heading by one level (``#`` → ``##``, etc.)."""
+    return _ATX_HEADING.sub(lambda m: "#" + m.group(1), text)
+
+
+def _normalize_unicode(text: str) -> str:
+    return text.replace("→", "->")
+
+
+def _indent_html(html: str, indent: str = "   ") -> str:
+    """Indent every line of ``html`` by ``indent`` for inclusion under ``.. raw:: html``."""
+    return "\n".join(indent + line if line else line for line in html.splitlines())
+
+
+def format_release_body(text: str) -> str:
+    """
+    Convert a GitHub release body (Markdown + embedded HTML) into an RST
+    ``.. raw:: html`` block wrapped in ``div.uplt-whats-new-release-body``.
+
+    Parameters
+    ----------
+    text : str
+        Raw Markdown release body as returned by the GitHub releases API.
+
+    Returns
+    -------
+    str
+        Indented RST snippet ready to be appended to ``whats_new.rst``.
+    """
+    cleaned = _downgrade_headings(
+        _normalize_unicode(_strip_pr_attribution(text or ""))
+    ).strip()
+    html_body = markdown.markdown(cleaned, extensions=list(_MD_EXTENSIONS))
+    wrapped = f'<div class="uplt-whats-new-release-body">\n{html_body}\n</div>'
+    return ".. raw:: html\n\n" + _indent_html(wrapped) + "\n"
+
+
+def _format_release_title(release: dict) -> str:
+    """
+    Build the per-release section title in ``"<tag>: <name>"`` form,
+    de-duplicating the tag if it is already a prefix of the release name.
+    """
+    tag = release["tag_name"].lower()
+    title = (release.get("name") or "").strip()
+    if title.lower().startswith(tag):
+        title = title[len(tag) :].lstrip(" :-—–")
+    return f"{tag}: {title}" if title else tag
+
+
+def fetch_all_releases() -> list[dict]:
+    """Fetch every GitHub release across paginated responses."""
+    releases: list[dict] = []
+    page = 1
+    while True:
+        response = requests.get(GITHUB_API_URL, params={"per_page": 30, "page": page})
+        if response.status_code != 200:
+            print(f"Error fetching releases: {response.status_code}")
+            break
+        page_data = response.json()
+        if not page_data:
+            break
+        releases.extend(page_data)
+        page += 1
+    return releases
+
+
+def _render_releases(releases: Iterable[dict]) -> str:
+    """Render an iterable of release dicts to the full ``whats_new.rst`` body."""
+    header = "What's new?"
+    out = f".. _whats_new:\n\n{header}\n{'=' * len(header)}\n\n"
+    for release in releases:
+        title = _format_release_title(release)
+        date = release["published_at"][:10]
+        heading = f"{title} ({date})"
+        out += f"{heading}\n{'-' * len(heading)}\n\n"
+        out += format_release_body(release.get("body") or "") + "\n"
+    return out
+
+
+def fetch_releases() -> str:
+    """Fetch the latest releases from GitHub and format them as RST."""
+    releases = fetch_all_releases()
+    if not releases:
+        print("Error fetching releases!")
+        return ""
+    return _render_releases(releases)
+
+
+def write_rst() -> None:
+    """Write fetched releases to ``whats_new.rst``."""
+    content = fetch_releases()
+    if content:
+        OUTPUT_RST.write_text(content, encoding="utf-8")
+        print(f"Updated {OUTPUT_RST}")
+    else:
+        print("No updates to write.")
+
+
+if __name__ == "__main__":
+    write_rst()

{ultraplot-2.1.9 → ultraplot-2.2.0}/docs/_static/custom.css

@@ -1212,3 +1212,41 @@ body.wy-body-for-nav
     border-radius: 0.2rem;
     background: var(--uplt-color-sidebar-bg);
 }
+
+/* What's-new release bodies generated by docs/_scripts/fetch_releases.py.
+   Each release is emitted inside a <div class="uplt-whats-new-release-body">
+   so we have a single styling hook for spacing, code-block padding, and the
+   <details> snippet affordance. */
+.uplt-whats-new-release-body {
+    margin-top: 0.5rem;
+    margin-bottom: 1.5rem;
+}
+
+.uplt-whats-new-release-body h2,
+.uplt-whats-new-release-body h3,
+.uplt-whats-new-release-body h4 {
+    margin-top: 1.25rem;
+    margin-bottom: 0.5rem;
+}
+
+.uplt-whats-new-release-body details {
+    margin: 0.5rem 0 1rem;
+    padding: 0.25rem 0.75rem;
+    border: 1px solid var(--uplt-color-sidebar-bg, #e5e7eb);
+    border-radius: 0.35rem;
+    background: var(--uplt-color-sidebar-bg, #f9fafb);
+}
+
+.uplt-whats-new-release-body details > summary {
+    cursor: pointer;
+    font-weight: 600;
+}
+
+.uplt-whats-new-release-body pre {
+    overflow-x: auto;
+}
+
+.uplt-whats-new-release-body img {
+    max-width: 100%;
+    height: auto;
+}

{ultraplot-2.1.9 → ultraplot-2.2.0}/environment.yml

@@ -20,5 +20,7 @@ dependencies:
   - networkx
   - pyarrow
   - cftime
+  - markdown
+  - requests
   - pip:
       - pycirclize

{ultraplot-2.1.9 → ultraplot-2.2.0}/pyproject.toml

@@ -74,7 +74,7 @@ docs = [
     "jupyter",
     "jupytext",
     "lxml-html-clean",
-    "m2r2",
+    "markdown",
     "mpltern",
     "nbsphinx",
     "sphinx",

{ultraplot-2.1.9 → ultraplot-2.2.0}/tools/release/publish_zenodo.py

@@ -288,19 +288,70 @@ def validate_inputs(dist_dir: Path, access_token: str | None) -> None:
         raise SystemExit(f"Distribution directory {dist_dir} does not contain files.")
 
 
+def find_existing_draft(api_url: str, token: str, record_id: int) -> dict | None:
+    record = api_request("GET", f"{api_url}/records/{record_id}", token=token)
+    conceptrecid = str(record.get("conceptrecid") or record.get("id"))
+
+    page = 1
+    while True:
+        payload = api_request(
+            "GET",
+            f"{api_url}/deposit/depositions?page={page}&size=100",
+            token=token,
+        )
+
+        if not payload:
+            break
+
+        for dep in payload:
+            if str(dep.get("conceptrecid")) != conceptrecid:
+                continue
+            if dep.get("submitted"):
+                continue
+
+            print(f"Found existing draft deposition {dep['id']}")
+            return dep
+
+        if len(payload) < 100:
+            break
+
+        page += 1
+
+    return None
+
+
+def get_or_create_draft(api_url: str, token: str, record_id: int) -> dict:
+    try:
+        return create_new_version(api_url, token, record_id)
+    except RuntimeError as exc:
+        message = str(exc)
+        if "files.enabled" not in message:
+            raise
+
+        draft = find_existing_draft(api_url, token, record_id)
+        if draft is None:
+            raise
+        print(f"Reusing existing Zenodo draft {draft['id']}.")
+        return draft
+
+
 def main() -> int:
     args = parse_args()
     validate_inputs(args.dist_dir, args.access_token)
-    citation = load_citation(args.citation)
+
+    citation = load_citation(args.citation_file)
     pyproject = load_pyproject(args.pyproject)
     metadata = build_metadata(citation, pyproject)
+
     conceptrecid = resolve_concept_recid(args.api_url, citation["doi"])
     record_id = latest_record_id(args.api_url, conceptrecid)
-    draft = create_new_version(args.api_url, args.access_token, record_id)
+
+    draft = get_or_create_draft(args.api_url, args.access_token, record_id)
     clear_draft_files(draft, args.access_token)
     upload_dist_files(draft, args.access_token, args.dist_dir)
     draft = update_metadata(draft, args.access_token, metadata)
     published = publish_draft(draft, args.access_token)
+
     doi = published.get("doi") or published.get("metadata", {}).get("doi")
     print(
         f"Published Zenodo release record {published['id']} for "

ultraplot-2.2.0/ultraplot/_version.py

@@ -0,0 +1 @@
+__version__ = '2.2.0'

{ultraplot-2.1.9 → ultraplot-2.2.0}/ultraplot/axes/base.py

@@ -2417,6 +2417,8 @@ class Axes(_ExternalModeMixin, maxes.Axes):
         """
         Reposition the subplot axes.
         """
+        # NOTE: The panel span override logic here will move to a layout
+        # composer in a future refactor.
         # WARNING: In later versions self.numRows, self.numCols, and self.figbox
         # are @property definitions that never go stale but in mpl < 3.4 they are
         # attributes that must be updated explicitly with update_params().
@@ -2460,9 +2462,9 @@ class Axes(_ExternalModeMixin, maxes.Axes):
             )
 
             # Check if the panel has a span override (spans more columns/rows
-            # than its parent). When it does, use the SubplotSpec position for
-            # the "along" dimension so the span is respected. Otherwise use
-            # parent_bbox which correctly tracks aspect-ratio adjustments.
+            # than its parent). When it does, compute the visual extent from
+            # actual axes positions so the panel aligns with aspect-adjusted
+            # axes rather than raw grid slots. Otherwise use parent_bbox.
             parent_ss = self._panel_parent.get_subplotspec().get_topmost_subplotspec()
             p_row1, p_row2, p_col1, p_col2 = parent_ss._get_rows_columns(
                 ncols=gs.ncols_total
@@ -2470,9 +2472,30 @@ class Axes(_ExternalModeMixin, maxes.Axes):
 
             if side in ("right", "left"):
                 has_span_override = (row1 < p_row1) or (row2 > p_row2)
-                along_bbox = (
-                    ss.get_position(self.figure) if has_span_override else parent_bbox
-                )
+                if has_span_override:
+                    # Compute visual extent from all axes in the span range
+                    vmin, vmax = float("inf"), float("-inf")
+                    for other in self.figure.axes:
+                        if getattr(other, "_panel_side", None):
+                            continue
+                        oss = getattr(other, "get_subplotspec", lambda: None)()
+                        if oss is None:
+                            continue
+                        oss = oss.get_topmost_subplotspec()
+                        if oss.get_gridspec() is not gs:
+                            continue
+                        o_r1, o_r2, _, _ = oss._get_rows_columns(ncols=gs.ncols_total)
+                        if o_r1 >= row1 and o_r2 <= row2:
+                            opos = other.get_position()
+                            vmin = min(vmin, opos.y0)
+                            vmax = max(vmax, opos.y1)
+                    if vmin < vmax:
+                        along_y0, along_h = vmin, vmax - vmin
+                    else:
+                        slot = ss.get_position(self.figure)
+                        along_y0, along_h = slot.y0, slot.height
+                else:
+                    along_y0, along_h = parent_bbox.y0, parent_bbox.height
                 boundary = None
                 width = sum(gs._wratios_total[col1 : col2 + 1]) / figwidth
                 if a_col2 < col1:
@@ -2492,14 +2515,32 @@ class Axes(_ExternalModeMixin, maxes.Axes):
                     x0 = anchor_bbox.x1 + pad
                 else:
                     x0 = anchor_bbox.x0 - pad - width
-                bbox = mtransforms.Bbox.from_bounds(
-                    x0, along_bbox.y0, width, along_bbox.height
-                )
+                bbox = mtransforms.Bbox.from_bounds(x0, along_y0, width, along_h)
             else:
                 has_span_override = (col1 < p_col1) or (col2 > p_col2)
-                along_bbox = (
-                    ss.get_position(self.figure) if has_span_override else parent_bbox
-                )
+                if has_span_override:
+                    vmin, vmax = float("inf"), float("-inf")
+                    for other in self.figure.axes:
+                        if getattr(other, "_panel_side", None):
+                            continue
+                        oss = getattr(other, "get_subplotspec", lambda: None)()
+                        if oss is None:
+                            continue
+                        oss = oss.get_topmost_subplotspec()
+                        if oss.get_gridspec() is not gs:
+                            continue
+                        _, _, o_c1, o_c2 = oss._get_rows_columns(ncols=gs.ncols_total)
+                        if o_c1 >= col1 and o_c2 <= col2:
+                            opos = other.get_position()
+                            vmin = min(vmin, opos.x0)
+                            vmax = max(vmax, opos.x1)
+                    if vmin < vmax:
+                        along_x0, along_w = vmin, vmax - vmin
+                    else:
+                        slot = ss.get_position(self.figure)
+                        along_x0, along_w = slot.x0, slot.width
+                else:
+                    along_x0, along_w = parent_bbox.x0, parent_bbox.width
                 boundary = None
                 height = sum(gs._hratios_total[row1 : row2 + 1]) / figheight
                 if a_row2 < row1:
@@ -2518,9 +2559,7 @@ class Axes(_ExternalModeMixin, maxes.Axes):
                     y0 = anchor_bbox.y1 + pad
                 else:
                     y0 = anchor_bbox.y0 - pad - height
-                bbox = mtransforms.Bbox.from_bounds(
-                    along_bbox.x0, y0, along_bbox.width, height
-                )
+                bbox = mtransforms.Bbox.from_bounds(along_x0, y0, along_w, height)
             setter(bbox)
 
     def _update_abc(self, **kwargs):

{ultraplot-2.1.9 → ultraplot-2.2.0}/ultraplot/axes/geo.py

@@ -1352,12 +1352,116 @@ class GeoAxes(shared._SharedAxes, plot.PlotAxes):
         self.apply_aspect()
         self._adjust_panel_positions(tol=tol)
 
+    def _compute_span_extent(self, side, panel, gs, p_r1, p_r2, p_c1, p_c2):
+        """
+        If the panel spans beyond the parent's SubplotSpec, compute the visual
+        extent (min, max) along the span axis from all non-panel axes in range.
+        Returns None if not a span override or no valid extent found.
+        """
+        # NOTE: This will move to a layout composer in a future refactor.
+        ss = getattr(panel, "get_subplotspec", lambda: None)()
+        if ss is None or p_c1 is None:
+            return None
+
+        panel_ss = ss.get_topmost_subplotspec()
+        s_r1, s_r2, s_c1, s_c2 = panel_ss._get_rows_columns(ncols=gs.ncols_total)
+
+        if side in ("bottom", "top"):
+            has_span_override = s_c1 < p_c1 or s_c2 > p_c2
+        elif side in ("left", "right"):
+            has_span_override = s_r1 < p_r1 or s_r2 > p_r2
+        else:
+            return None
+
+        if not has_span_override:
+            return None
+
+        vmin, vmax = float("inf"), float("-inf")
+        for other_ax in self.figure.axes:
+            if getattr(other_ax, "_panel_side", None):
+                continue
+            oss = getattr(other_ax, "get_subplotspec", lambda: None)()
+            if oss is None:
+                continue
+            oss = oss.get_topmost_subplotspec()
+            if oss.get_gridspec() is not gs:
+                continue
+            o_r1, o_r2, o_c1, o_c2 = oss._get_rows_columns(ncols=gs.ncols_total)
+            opos = other_ax.get_position()
+            if side in ("left", "right"):
+                if o_r1 >= s_r1 and o_r2 <= s_r2:
+                    vmin = min(vmin, opos.y0)
+                    vmax = max(vmax, opos.y1)
+            else:
+                if o_c1 >= s_c1 and o_c2 <= s_c2:
+                    vmin = min(vmin, opos.x0)
+                    vmax = max(vmax, opos.x1)
+
+        return (vmin, vmax) if vmin < vmax else None
+
+    @staticmethod
+    def _compute_adjusted_panel_pos(
+        side, panel_pos, span_extent, original_pos, main_pos, sx, sy, tol
+    ):
+        """
+        Compute the new [x0, y0, width, height] for a panel on the given side,
+        accounting for aspect-adjusted main axes and optional span extent.
+        Returns the new position list, or None for unknown sides.
+        """
+        # NOTE: This will move to a layout composer in a future refactor.
+        ox0, oy0 = original_pos.x0, original_pos.y0
+        ox1, oy1 = original_pos.x1, original_pos.y1
+        mx0, my0 = main_pos.x0, main_pos.y0
+        px0, py0 = panel_pos.x0, panel_pos.y0
+        px1, py1 = panel_pos.x1, panel_pos.y1
+
+        if side in ("left", "right"):
+            # Compute vertical extent
+            if span_extent is not None:
+                along_y0 = span_extent[0]
+                along_h = span_extent[1] - span_extent[0]
+            elif py0 <= oy0 + tol and py1 >= oy1 - tol:
+                along_y0, along_h = my0, main_pos.height
+            else:
+                along_y0 = my0 + (panel_pos.y0 - oy0) * sy
+                along_h = panel_pos.height * sy
+
+            if side == "left":
+                gap = original_pos.x0 - (panel_pos.x0 + panel_pos.width)
+                new_x0 = main_pos.x0 - panel_pos.width - gap
+            else:
+                gap = panel_pos.x0 - (original_pos.x0 + original_pos.width)
+                new_x0 = main_pos.x0 + main_pos.width + gap
+            return [new_x0, along_y0, panel_pos.width, along_h]
+
+        elif side in ("top", "bottom"):
+            # Compute horizontal extent
+            if span_extent is not None:
+                along_x0 = span_extent[0]
+                along_w = span_extent[1] - span_extent[0]
+            elif px0 <= ox0 + tol and px1 >= ox1 - tol:
+                along_x0, along_w = mx0, main_pos.width
+            else:
+                along_x0 = mx0 + (panel_pos.x0 - ox0) * sx
+                along_w = panel_pos.width * sx
+
+            if side == "top":
+                gap = panel_pos.y0 - (original_pos.y0 + original_pos.height)
+                new_y0 = main_pos.y0 + main_pos.height + gap
+            else:
+                gap = original_pos.y0 - (panel_pos.y0 + panel_pos.height)
+                new_y0 = main_pos.y0 - panel_pos.height - gap
+            return [along_x0, new_y0, along_w, panel_pos.height]
+
+        return None
+
     def _adjust_panel_positions(self, *, tol: float = 1e-9) -> None:
         """
         Adjust panel positions to align with the aspect-constrained main axes.
         After apply_aspect() shrinks the main axes, panels should flank the actual
         map boundaries rather than the full gridspec allocation.
         """
+        # NOTE: This will move to a layout composer in a future refactor.
         if not getattr(self, "_panel_dict", None):
             return  # no panels to adjust
 
@@ -1366,11 +1470,8 @@ class GeoAxes(shared._SharedAxes, plot.PlotAxes):
 
         # Subplot-spec position before apply_aspect(). This is the true "gridspec slot"
         # and remains well-defined even if we temporarily modify axes positions.
-        try:
-            ss = self.get_subplotspec()
-            original_pos = ss.get_position(self.figure) if ss is not None else None
-        except Exception:
-            original_pos = None
+        ss = getattr(self, "get_subplotspec", lambda: None)()
+        original_pos = ss.get_position(self.figure) if ss is not None else None
         if original_pos is None:
             original_pos = getattr(
                 self, "_originalPosition", None
@@ -1390,87 +1491,46 @@ class GeoAxes(shared._SharedAxes, plot.PlotAxes):
         # panel, so span overrides across subplot rows/cols are preserved).
         sx = main_pos.width / original_pos.width if original_pos.width else 1.0
         sy = main_pos.height / original_pos.height if original_pos.height else 1.0
-        ox0, oy0 = original_pos.x0, original_pos.y0
-        ox1, oy1 = (
-            original_pos.x0 + original_pos.width,
-            original_pos.y0 + original_pos.height,
-        )
-        mx0, my0 = main_pos.x0, main_pos.y0
+
+        # Detect span overrides by comparing SubplotSpec extents of parent vs panels
+        parent_ss = getattr(self, "get_subplotspec", lambda: None)()
+        if parent_ss is not None:
+            parent_ss = parent_ss.get_topmost_subplotspec()
+            gs = parent_ss.get_gridspec()
+            p_r1, p_r2, p_c1, p_c2 = parent_ss._get_rows_columns(ncols=gs.ncols_total)
+        else:
+            gs = None
+            p_r1 = p_r2 = p_c1 = p_c2 = None
 
         for side, panels in self._panel_dict.items():
             for panel in panels:
                 # Use the panel subplot-spec box as the baseline (not its current
                 # original position) to avoid accumulated adjustments.
-                try:
-                    ss = panel.get_subplotspec()
-                    panel_pos = (
-                        ss.get_position(panel.figure) if ss is not None else None
-                    )
-                except Exception:
-                    panel_pos = None
+                ss = getattr(panel, "get_subplotspec", lambda: None)()
+                panel_pos = ss.get_position(panel.figure) if ss is not None else None
                 if panel_pos is None:
                     panel_pos = panel.get_position(original=True)
-                px0, py0 = panel_pos.x0, panel_pos.y0
-                px1, py1 = (
-                    panel_pos.x0 + panel_pos.width,
-                    panel_pos.y0 + panel_pos.height,
-                )
-
-                # Use _set_position when available to avoid layoutbox side effects
-                # from public set_position() on newer matplotlib versions.
-                setter = getattr(panel, "_set_position", panel.set_position)
 
-                if side == "left":
-                    # Calculate original gap between panel and main axes
-                    gap = original_pos.x0 - (panel_pos.x0 + panel_pos.width)
-                    # Position panel to the left of the adjusted main axes
-                    new_x0 = main_pos.x0 - panel_pos.width - gap
-                    if py0 <= oy0 + tol and py1 >= oy1 - tol:
-                        new_y0, new_h = my0, main_pos.height
-                    else:
-                        new_y0 = my0 + (panel_pos.y0 - oy0) * sy
-                        new_h = panel_pos.height * sy
-                    new_pos = [new_x0, new_y0, panel_pos.width, new_h]
-                elif side == "right":
-                    # Calculate original gap
-                    gap = panel_pos.x0 - (original_pos.x0 + original_pos.width)
-                    # Position panel to the right of the adjusted main axes
-                    new_x0 = main_pos.x0 + main_pos.width + gap
-                    if py0 <= oy0 + tol and py1 >= oy1 - tol:
-                        new_y0, new_h = my0, main_pos.height
-                    else:
-                        new_y0 = my0 + (panel_pos.y0 - oy0) * sy
-                        new_h = panel_pos.height * sy
-                    new_pos = [new_x0, new_y0, panel_pos.width, new_h]
-                elif side == "top":
-                    # Calculate original gap
-                    gap = panel_pos.y0 - (original_pos.y0 + original_pos.height)
-                    # Position panel above the adjusted main axes
-                    new_y0 = main_pos.y0 + main_pos.height + gap
-                    if px0 <= ox0 + tol and px1 >= ox1 - tol:
-                        new_x0, new_w = mx0, main_pos.width
-                    else:
-                        new_x0 = mx0 + (panel_pos.x0 - ox0) * sx
-                        new_w = panel_pos.width * sx
-                    new_pos = [new_x0, new_y0, new_w, panel_pos.height]
-                elif side == "bottom":
-                    # Calculate original gap
-                    gap = original_pos.y0 - (panel_pos.y0 + panel_pos.height)
-                    # Position panel below the adjusted main axes
-                    new_y0 = main_pos.y0 - panel_pos.height - gap
-                    if px0 <= ox0 + tol and px1 >= ox1 - tol:
-                        new_x0, new_w = mx0, main_pos.width
-                    else:
-                        new_x0 = mx0 + (panel_pos.x0 - ox0) * sx
-                        new_w = panel_pos.width * sx
-                    new_pos = [new_x0, new_y0, new_w, panel_pos.height]
-                else:
-                    # Unknown side, skip adjustment
+                span_extent = self._compute_span_extent(
+                    side, panel, gs, p_r1, p_r2, p_c1, p_c2
+                )
+                new_pos = self._compute_adjusted_panel_pos(
+                    side,
+                    panel_pos,
+                    span_extent,
+                    original_pos,
+                    main_pos,
+                    sx,
+                    sy,
+                    tol,
+                )
+                if new_pos is None:
                     continue
 
                 # Panels typically have aspect='auto', which causes matplotlib to
                 # reset their *active* position to their *original* position inside
                 # apply_aspect()/get_position(). Update both so the change persists.
+                setter = getattr(panel, "_set_position", panel.set_position)
                 try:
                     setter(new_pos, which="both")
                 except TypeError:  # older matplotlib