matplotlib · rbt94 · Feb 18, 2023 · Feb 19, 2023 · Feb 19, 2023 · Feb 19, 2023
diff --git a/.flake8 b/.flake8
@@ -94,4 +94,4 @@ per-file-ignores =
     galleries/examples/user_interfaces/pylab_with_gtk3_sgskip.py: E402
     galleries/examples/user_interfaces/pylab_with_gtk4_sgskip.py: E402
     galleries/examples/userdemo/pgf_preamble_sgskip.py: E402
-force-check = True
+force-check = True
diff --git a/.github/workflows/cibuildwheel.yml b/.github/workflows/cibuildwheel.yml
@@ -61,6 +61,14 @@ jobs:
         with:
           fetch-depth: 0
 
+      # Something changed somewhere that prevents the downloaded-at-build-time
+      # licenses from being included in built wheels, so pre-download them so
+      # that they exist before the build and are included.
+      - name: Pre-download bundled licenses
+        run: >
+          curl -Lo LICENSE/LICENSE_QHULL
+          https://github.com/qhull/qhull/raw/2020.2/COPYING.txt
+
       - name: Build wheels for CPython 3.11
         uses: pypa/cibuildwheel@v2.12.0
         env:

diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
@@ -0,0 +1,25 @@
+name: 'Label inactive PRs'
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+jobs:
+  stale:
+    if: github.repository == 'matplotlib/matplotlib'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v7
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          operations-per-run: 50
+          stale-pr-message: 'Since this Pull Request has not been updated in 60 days, it has been marked "inactive." This does not mean that it will be closed, though it may be moved to a "Draft" state.  This helps maintainers prioritize their reviewing efforts. You can pick the PR back up anytime - please ping us if you need a review or guidance to move the PR forward!  If you do not plan on continuing the work, please let us know so that we can either find someone to take the PR over, or close it.'
+          stale-pr-label: 'inactive'
+          days-before-pr-stale: 60
+          days-before-pr-close: -1
+          stale-issue-message: 'This issue has been marked "inactive" because it has been 365 days since the last comment. If this issue is still present in recent Matplotlib releases, or the feature request is still wanted, please leave a comment and this label will be removed. If there are no updates in another 30 days, this issue will be automatically closed, but you are free to re-open or create a new issue if needed. We value issue reports, and this procedure is meant to help us resurface and prioritize issues that have not been addressed yet, not make them disappear.  Thanks for your help!'
+          stale-issue-label: 'inactive'
+          days-before-issue-stale: 365
+          days-before-issue-close: 30
+          ascending: true
+          exempt-issue-labels: "keep"
+          exempt-pr-labels: "keep,status: orphaned PR"
diff --git a/doc/api/next_api_changes/deprecations/25352-GL.rst b/doc/api/next_api_changes/deprecations/25352-GL.rst
@@ -0,0 +1,4 @@
+``Grouper.clean()``
+~~~~~~~~~~~~~~~~~~~
+
+with no replacement. The Grouper class now cleans itself up automatically.
diff --git a/doc/users/explain/interactive.rst b/doc/users/explain/interactive.rst
@@ -269,7 +269,7 @@ Jupyter Notebooks / JupyterLab
    cells.
 
 To get interactive figures in the 'classic' notebook or Jupyter lab,
-use the `ipympl <https://github.com/matplotlib/ipympl>`__ backend
+use the `ipympl <https://matplotlib.org/ipympl>`__ backend
 (must be installed separately) which uses the **ipywidget** framework.
 If ``ipympl`` is installed use the magic:
 

diff --git a/galleries/examples/specialty_plots/ishikawa.py b/galleries/examples/specialty_plots/ishikawa.py
@@ -0,0 +1,223 @@
+"""
+=================
+Ishikawa Diagrams
+=================
+
+Ishikawa Diagrams, fishbone diagrams, herringbone diagrams, or cause-and-effect
+diagrams are useful for visualizing the effect to many cause relationships
+Source: https://en.wikipedia.org/wiki/Ishikawa_diagram
+
+"""
+from typing import List
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib
+
+
+def drawspines(data: dict, ax: plt.Axes, parentspine: None,
+               primary_spine_angle: float = 60.0,
+               secondary_spine_angle: float = 0,
+               primary_spines_rel_xpos: List[float] = [np.nan],
+               spine_color: str = "black", reclevel: int = 1,
+               max_recursion_level: int = 4):
+    """
+    Draw an Ishikawa spine with recursion
+
+    Parameters
+    ----------
+    data : dict
+        dictionary structure containing problem, causes...
+    ax : plt.Axes
+        Matplotlib current axes
+    parentspine : None
+        Parent spine object
+    primary_spine_angle : float, optional
+        First spine angle using during recursion. The default is 60.0.
+    secondary_spine_angle : float, optional
+        Secondary spine angle using during recursion. The default is 0.
+    primary_spines_rel_xpos : List[float], optional
+        Relative X-position of primary spines, a list of float is accepted.
+        The default is [np.nan].
+    spine_color : str, optional
+        Spine color. The default is "black".
+    reclevel : int, optional
+        Current recursion level. The default is 1.
+    max_recursion_level : int, optional
+        Maximum recursion level set. The default is 4.
+
+    Raises
+    ------
+    AttributeError
+        Maximum recursion level reached or passed a bad parentspine object format.
+
+    Returns
+    -------
+    None.
+
+    """
+    # stop recursion if maximum level reached
+    if reclevel > max_recursion_level:
+        raise AttributeError('Max Recursion Level Reached')
+
+    if isinstance(data, dict):
+        # switch to correct angle depending on recursion level
+        if reclevel % 2 != 0:
+            alpha = primary_spine_angle
+        else:
+            alpha = secondary_spine_angle
+
+        if isinstance(parentspine, matplotlib.lines.Line2D):
+            # calculate parent data
+            ([xpb, xpe], [ypb, ype]) = parentspine.get_data()
+        elif isinstance(parentspine, matplotlib.text.Annotation):
+            xpb, ypb = parentspine.xy
+            xpe, ype = parentspine._x, parentspine._y  # parentspine._arrow_relpos
+        else:
+            raise AttributeError('Wrong Spine Graphical Element')
+
+        plen = np.hypot(xpe - xpb, ype - ypb)
+        palpha = np.round(np.degrees(np.arctan2(ype - ypb, xpe - xpb)))
+
+        # calculate spine spacing
+        # calculate couple pairs, at least 1 pair to start at middle branch
+        pairs = np.ceil(len(data) / 2) + 1
+        spacing = plen / pairs
+
+        spine_count = 0
+        s = spacing
+        # draw spine
+        for problem, cause in data.items():
+            # calculate arrow position in the graph
+            # fix primary spines spacing
+            if reclevel == 1:
+                if len(primary_spines_rel_xpos) == len(data):
+                    x_end = primary_spines_rel_xpos[spine_count]
+                else:
+                    x_end = xpe - (s / 1.5) * np.cos(np.radians(palpha))
+                y_end = ype - s * np.sin(np.radians(palpha))
+
+                x_start = x_end - s * np.cos(np.radians(alpha))
+                y_start = y_end - s * np.sin(np.radians(alpha))
+            else:
+                x_end = xpe - s * np.cos(np.radians(palpha))
+                y_end = ype - s * np.sin(np.radians(palpha))
+
+                x_start = x_end - s * np.cos(np.radians(alpha))
+                y_start = y_end - s * np.sin(np.radians(alpha))
+
+            # draw arrow arc
+            if reclevel == 1:
+                props = dict(boxstyle='round', facecolor='lightsteelblue', alpha=1.0)
+                spine = ax.annotate(problem.upper(), xy=(x_end, y_end),
+                                    xytext=(x_start, y_start),
+                                    arrowprops=dict(arrowstyle="->",
+                                                    facecolor=spine_color),
+                                    bbox=props, weight='bold')
+            else:
+                props = dict(boxstyle='round', facecolor='lavender', alpha=1.0)
+                spine = ax.annotate(problem, xy=(x_end, y_end),
+                                    xytext=(x_start, y_start),
+                                    arrowprops=dict(arrowstyle="->",
+                                                    facecolor=spine_color),
+                                    bbox=props)
+            # Call recursion to draw subspines
+            drawspines(data=cause, ax=ax, parentspine=spine,
+                       primary_spine_angle=primary_spine_angle,
+                       secondary_spine_angle=secondary_spine_angle,
+                       spine_color=spine_color, reclevel=reclevel + 1,
+                       max_recursion_level=max_recursion_level)
+            # no primary_spines_rel_xpos is needed to be passed on recursion
+            # next spine settings - same level
+            alpha *= -1
+            spine_count += 1
+            if spine_count % 2 == 0:
+                s = s + spacing
+    return None
+
+
+def ishikawaplot(data: dict, ax: plt.Axes, left_margin: float = 0.05,
+                 right_margin: float = 0.05,
+                 primary_spine_angle: float = 60.0,
+                 secondary_spine_angle: float = 0.0,
+                 primary_spines_rel_xpos: List[float] = [np.nan],
+                 pd_width: int = 0.1, spine_color: str = "black") -> None:
+    """
+
+    Parameters
+    ----------
+    data : dict
+        Plot data structure.
+    ax : matplotlib.pyplot.Axes
+        Axes in which to drow the plot.
+    left_margin : float, optional
+        Left spacing from frame border. The default is 0.05.
+    right_margin : float, optional
+        Right spacing from frame border. The default is 0.05.
+    primary_spine_angle : float, optional
+        First spine angle using during recursion. The default is 60.0.
+    secondary_spine_angle : float, optional
+        Secondary spine angle using during recursion. The default is 0.0.
+    primary_spines_rel_xpos : list, optional
+        Relative X-position of primary spines, a list of float is accepted.
+        The default is [np.nan].
+    pd_width : int, optional
+        Problem description box relative width. The default is 0.1.
+    spine_color : str, optional
+        Spine color. The default is "black".
+
+    Returns
+    -------
+    None
+
+    """
+    # format axis
+    ax.set_xlim(0, 1.0)
+    ax.set_ylim(0, 1.0)
+    ax.axis('off')
+
+    # draw main spine
+    main_spine = ax.axhline(y=0.5, xmin=left_margin,
+                            xmax=1 - right_margin - pd_width,
+                            color=spine_color)
+
+    # draw fish head
+    props = dict(boxstyle='round', facecolor='wheat', alpha=1.0)
+    # add problem tag
+    ax.text((1 - right_margin - pd_width), 0.5, str.upper(list(data.keys())[0]),
+            fontsize=12, weight='bold',
+            verticalalignment='center', horizontalalignment='left', bbox=props)
+
+    # draw fish tail
+    x = (0.0, 0.0, left_margin)
+    y = (0.5 - left_margin, 0.5 + left_margin, 0.5)
+    ax.fill(x, y, color=spine_color)
+
+    # draw spines with recursion
+    drawspines(data=data[list(data.keys())[0]], ax=ax, parentspine=main_spine,
+               primary_spine_angle=primary_spine_angle,
+               secondary_spine_angle=secondary_spine_angle,
+               primary_spines_rel_xpos=primary_spines_rel_xpos,
+               spine_color=spine_color)
+
+    return None
+
+
+# USER DATA
+data = {'problem': {'machine': {'cause1': ''},
+                    'process': {'cause2': {'subcause1': '', 'subcause2': ''}
+                                },
+                    'man': {'cause3': {'subcause3': '', 'subcause4': ''}
+                            },
+                    'design': {'cause4': {'subcause5': '', 'subcause6': ''}
+                               }
+
+                    }
+        }
+
+# Ishikawa plot generation
+fig, ax = plt.subplots(figsize=(12, 6), layout='constrained')
+
+# try also without opt primary_spines rel_xpos
+ishikawaplot(data, ax, primary_spines_rel_xpos=[0.8, 0.7, 0.6, 0.4])