Address review: simplify arc docstring/comments and trim polar tests

- Drop the contrast and GitHub issue references from the Path.arc
  docstring; just state that a complete circle is drawn.
- Remove issue references and reword the test_path.py comments for a
  reader unfamiliar with this PR's history.
- Make test_arc_full_circle_snap compare all vertices against the
  reference circle, consistent with (and slightly stricter than) the
  neighbouring test.
- Remove test_polar_transform_constant_r_arc (it passes against main and
  no longer guards the fix) and merge the two outer-spine tests into a
  single test_polar_outer_spine_not_collapsed using the spine bbox.

Author: SharadhNaidu

lib/matplotlib/path.py

@@ -980,8 +980,7 @@ def arc(cls, theta1, theta2, n=None, is_wedge=False):
 
         As a special case, if the span *theta2* - *theta1* is within
         floating-point tolerance of a whole number of turns, a complete circle
-        is drawn rather than collapsing a delta of 360*n plus a tiny rounding
-        error to a near-empty arc (matplotlib issues #20388 and #26972).
+        is drawn.
 
         If *n* is provided, it is the number of spline segments to make.
         If *n* is not provided, the number of spline segments is

lib/matplotlib/tests/test_path.py

@@ -519,20 +519,15 @@ def test_full_arc(offset):
 ])
 def test_arc_full_circle_snap(theta2):
     # A span within floating-point tolerance of a whole number of turns must
-    # draw a complete circle, not collapse to a near-empty arc.  This is the
-    # floating-point edge case behind gh-20388 and gh-26972.
-    full = Path.arc(0, 360)
-    snapped = Path.arc(0, theta2)
-    assert len(snapped.vertices) == len(full.vertices)
-    np.testing.assert_allclose(np.min(snapped.vertices, axis=0), -1, atol=1e-12)
-    np.testing.assert_allclose(np.max(snapped.vertices, axis=0), 1, atol=1e-12)
+    # draw a complete circle, not collapse to a near-empty arc.
+    np.testing.assert_allclose(Path.arc(0, theta2).vertices,
+                               Path.arc(0, 360).vertices)
 
 
 @pytest.mark.parametrize('theta1, theta2', [(0, -360), (0, -720), (360, 0),
                                             (10, -350)])
 def test_arc_negative_full_circle(theta1, theta2):
-    # An exact negative multiple of 360 must still draw a complete circle,
-    # matching the legacy behaviour (regression guard for the unwrap rework).
+    # An exact negative multiple of 360 must draw a complete circle.
     # The result is the same complete circle as the equivalent positive turn
     # starting from *theta1* (so the assertion holds for non-cardinal starts).
     np.testing.assert_allclose(Path.arc(theta1, theta2).vertices,
@@ -541,7 +536,7 @@ def test_arc_negative_full_circle(theta1, theta2):
 
 def test_arc_unwrap_partial_turn():
     # A span comfortably more than a whole number of turns (not near-integer)
-    # is still unwrapped to the equivalent shortest arc within 360 degrees.
+    # is unwrapped to the equivalent shortest arc within 360 degrees.
     np.testing.assert_allclose(Path.arc(0, 410).vertices,
                                Path.arc(0, 50).vertices)
     np.testing.assert_allclose(Path.arc(0, 540).vertices,

lib/matplotlib/tests/test_polar.py

@@ -5,7 +5,6 @@
 import pytest
 
 import matplotlib as mpl
-from matplotlib.path import Path
 from matplotlib.projections.polar import RadialLocator
 from matplotlib import pyplot as plt
 from matplotlib.testing.decorators import image_comparison, check_figures_equal
@@ -329,54 +328,26 @@ def test_polar_gridlines():
     assert ax.yaxis.majorTicks[0].gridline.get_alpha() == .2
 
 
-@pytest.mark.parametrize('span_deg', [359.999999, 360.0,
-                                      360 - 1e-9, 720.0])
-def test_polar_transform_constant_r_arc(span_deg):
-    # PolarTransform's chunking boundary used to disagree with Path.arc's
-    # angle-unwrap step, so an angular delta of nearly-but-not-exactly
-    # 360 degrees collapsed to a near-empty arc. Apply the transform to
-    # a constant-r path of varying angular span and check that the
-    # result remains a non-degenerate circle.
+@pytest.mark.parametrize('theta_zero_location, theta_offset', [
+    (("N", 20), None),
+    (("N", 30), None),
+    (None, 1.570796327),
+])
+def test_polar_outer_spine_not_collapsed(theta_zero_location, theta_offset):
+    # The polar outer spine spans a full turn via Path.arc.  For some theta
+    # offsets/directions, floating-point error left the span just short of a
+    # full 360 degrees and the spine collapsed to a near-empty arc.  Check it
+    # still occupies a sensible area.
     fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
+    if theta_zero_location is not None:
+        ax.set_theta_direction(-1)
+        ax.set_theta_zero_location(*theta_zero_location)
+    if theta_offset is not None:
+        ax.set_theta_offset(theta_offset)
     fig.canvas.draw()
-    r = 1.0
-    path = Path([(0.0, r), (np.deg2rad(span_deg), r)],
-                [Path.MOVETO, Path.LINETO])
-    path._interpolation_steps = 100
-    out = ax.transProjection.transform_path_non_affine(path)
-    spread = np.ptp(out.vertices, axis=0)
-    assert spread.min() > r * 1.5, (
-        f"transformed arc collapsed for span={span_deg}: spread={spread}")
-
-
-@pytest.mark.parametrize('angle', [10, 20, 30, 45, 90, 110])
-def test_polar_inverted_theta_outer_spine(angle):
-    # With set_theta_direction(-1) and certain values of
-    # set_theta_zero_location offset, the polar outer spine used to
-    # collapse to a near-empty arc.
-    fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
-    ax.set_theta_direction(-1)
-    ax.set_theta_zero_location("N", angle)
-    fig.canvas.draw()
-    spine = ax.spines['polar']
-    tpath = spine.get_transform().transform_path(spine.get_path())
-    spread = np.ptp(tpath.vertices, axis=0)
-    assert spread.min() > 50, (
-        f"outer spine collapsed for angle={angle}: spread={spread}")
-
-
-@pytest.mark.parametrize('offset', [1.0, np.pi / 2, np.pi, 1.570796327])
-def test_polar_theta_offset_outer_spine(offset):
-    # set_theta_offset used to remove the outer spine outline; same
-    # floating-point root cause as the inverted-theta case above.
-    fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
-    ax.set_theta_offset(offset)
-    fig.canvas.draw()
-    spine = ax.spines['polar']
-    tpath = spine.get_transform().transform_path(spine.get_path())
-    spread = np.ptp(tpath.vertices, axis=0)
-    assert spread.min() > 50, (
-        f"outer spine collapsed for theta_offset={offset}: spread={spread}")
+    # A collapsed spine has a near-zero (~1e-13) bounding box; a healthy one is
+    # hundreds of points across.
+    assert ax.spines['polar'].get_tightbbox().size.min() > 1
 
 
 def test_get_tightbbox_polar():