Annotation cleanups.

anntzer · anntzer · commit 8138d84b1da0 · 2023-04-17T09:44:46.000+02:00
- Make error messages more consistent.
- Remove commonted-out handling of xycoords="bbox"; the functionality of
  specifiying coordinates relative to a bbox is already provided by
  passing a callable that ignores its input and returns that bbox.
- Make _get_xy take xy as a single argument instead of two; merge the
  equivalent _get_ref_xy and _get_position_xy.  In offsetbox, no need to
  specifically handle self.boxcoords being a tuple: _get_xy already
  handles that case.  Also rename the last parameter of _get_xy to the
  more meaningful "coords".
diff --git a/doc/api/next_api_changes/behavior/25697-AL.rst b/doc/api/next_api_changes/behavior/25697-AL.rst
@@ -0,0 +1,3 @@
+Invalid types for Annotation xycoords now raise TypeError
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Previously, a `RuntimeError` would be raised in some cases.
diff --git a/lib/matplotlib/offsetbox.py b/lib/matplotlib/offsetbox.py
@@ -1400,19 +1400,9 @@ def get_tightbbox(self, renderer=None):
                            for child in self.get_children()])
 
     def update_positions(self, renderer):
-        """
-        Update pixel positions for the annotated point, the text and the arrow.
-        """
-
-        x, y = self.xybox
-        if isinstance(self.boxcoords, tuple):
-            xcoord, ycoord = self.boxcoords
-            x1, y1 = self._get_xy(renderer, x, y, xcoord)
-            x2, y2 = self._get_xy(renderer, x, y, ycoord)
-            ox0, oy0 = x1, y2
-        else:
-            ox0, oy0 = self._get_xy(renderer, x, y, self.boxcoords)
+        """Update pixel positions for the annotated point, the text, and the arrow."""
 
+        ox0, oy0 = self._get_xy(renderer, self.xybox, self.boxcoords)
         bbox = self.offsetbox.get_bbox(renderer)
         fw, fh = self._box_alignment
         self.offsetbox.set_offset(
diff --git a/lib/matplotlib/tests/test_text.py b/lib/matplotlib/tests/test_text.py
@@ -248,8 +248,8 @@ def test_annotation_contains():
 
 
 @pytest.mark.parametrize('err, xycoords, match', (
-    (RuntimeError, print, "Unexpected return type from callable"),
-    (RuntimeError, [0, 0], r"Unexpected type for 'xycoords'"),
+    (TypeError, print, "xycoords callable must return a BboxBase or Transform, not a"),
+    (TypeError, [0, 0], r"'xycoords' must be an instance of str, tuple"),
     (ValueError, "foo", "'foo' is not a valid coordinate"),
     (ValueError, "foo bar", "'foo bar' is not a valid coordinate"),
     (ValueError, "offset foo", "xycoords cannot be an offset coordinate"),
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -1431,59 +1431,56 @@ def __init__(self,
 
         self._draggable = None
 
-    def _get_xy(self, renderer, x, y, s):
-        if isinstance(s, tuple):
-            s1, s2 = s
-        else:
-            s1, s2 = s, s
-        if s1 == 'data':
+    def _get_xy(self, renderer, xy, coords):
+        x, y = xy
+        xcoord, ycoord = coords if isinstance(coords, tuple) else (coords, coords)
+        if xcoord == 'data':
             x = float(self.convert_xunits(x))
-        if s2 == 'data':
+        if ycoord == 'data':
             y = float(self.convert_yunits(y))
-        return self._get_xy_transform(renderer, s).transform((x, y))
+        return self._get_xy_transform(renderer, coords).transform((x, y))
 
-    def _get_xy_transform(self, renderer, s):
+    def _get_xy_transform(self, renderer, coords):
 
-        if isinstance(s, tuple):
-            s1, s2 = s
+        if isinstance(coords, tuple):
+            xcoord, ycoord = coords
             from matplotlib.transforms import blended_transform_factory
-            tr1 = self._get_xy_transform(renderer, s1)
-            tr2 = self._get_xy_transform(renderer, s2)
-            tr = blended_transform_factory(tr1, tr2)
-            return tr
-        elif callable(s):
-            tr = s(renderer)
+            tr1 = self._get_xy_transform(renderer, xcoord)
+            tr2 = self._get_xy_transform(renderer, ycoord)
+            return blended_transform_factory(tr1, tr2)
+        elif callable(coords):
+            tr = coords(renderer)
             if isinstance(tr, BboxBase):
                 return BboxTransformTo(tr)
             elif isinstance(tr, Transform):
                 return tr
             else:
-                raise RuntimeError(
-                    f"Unexpected return type from callable: "
-                    f"expected BboxBase or Transform, but got {type(tr).__name__}.")
-        elif isinstance(s, Artist):
-            bbox = s.get_window_extent(renderer)
+                raise TypeError(
+                    f"xycoords callable must return a BboxBase or Transform, not a "
+                    f"{type(tr).__name__}")
+        elif isinstance(coords, Artist):
+            bbox = coords.get_window_extent(renderer)
             return BboxTransformTo(bbox)
-        elif isinstance(s, BboxBase):
-            return BboxTransformTo(s)
-        elif isinstance(s, Transform):
-            return s
-        elif not isinstance(s, str):
-            raise RuntimeError(
-                f"Unexpected type for 'xycoords'. This must be one of str, (str, str), "
-                f"Artist, Transform, or callable, but got {type(s).__name__}.")
-
-        if s == 'data':
+        elif isinstance(coords, BboxBase):
+            return BboxTransformTo(coords)
+        elif isinstance(coords, Transform):
+            return coords
+        elif not isinstance(coords, str):
+            raise TypeError(
+                f"'xycoords' must be an instance of str, tuple[str, str], Artist, "
+                f"Transform, or Callable, not a {type(coords).__name__}")
+
+        if coords == 'data':
             return self.axes.transData
-        elif s == 'polar':
+        elif coords == 'polar':
             from matplotlib.projections import PolarAxes
             tr = PolarAxes.PolarTransform()
             trans = tr + self.axes.transData
             return trans
 
-        s_ = s.split()
+        s_ = coords.split()
         if len(s_) != 2:
-            raise ValueError(f"{s!r} is not a valid coordinate")
+            raise ValueError(f"{coords!r} is not a valid coordinate")
 
         bbox0, xy0 = None, None
 
@@ -1495,16 +1492,11 @@ def _get_xy_transform(self, renderer, s):
             bbox0 = self.figure.bbox
         elif bbox_name == "axes":
             bbox0 = self.axes.bbox
-        # elif bbox_name == "bbox":
-        #     if bbox is None:
-        #         raise RuntimeError("bbox is specified as a coordinate but "
-        #                            "never set")
-        #     bbox0 = self._get_bbox(renderer, bbox)
 
         if bbox0 is not None:
             xy0 = bbox0.p0
         elif bbox_name == "offset":
-            xy0 = self._get_ref_xy(renderer)
+            xy0 = self._get_position_xy(renderer)
 
         if xy0 is not None:
             # reference x, y in display coordinate
@@ -1528,24 +1520,7 @@ def _get_xy_transform(self, renderer, s):
             return tr.translate(ref_x, ref_y)
 
         else:
-            raise ValueError(f"{s!r} is not a valid coordinate")
-
-    def _get_ref_xy(self, renderer):
-        """
-        Return x, y (in display coordinates) that is to be used for a reference
-        of any offset coordinate.
-        """
-        return self._get_xy(renderer, *self.xy, self.xycoords)
-
-    # def _get_bbox(self, renderer):
-    #     if hasattr(bbox, "bounds"):
-    #         return bbox
-    #     elif hasattr(bbox, "get_window_extent"):
-    #         bbox = bbox.get_window_extent()
-    #         return bbox
-    #     else:
-    #         raise ValueError("A bbox instance is expected but got %s" %
-    #                          str(bbox))
+            raise ValueError(f"{coords!r} is not a valid coordinate")
 
     def set_annotation_clip(self, b):
         """
@@ -1572,8 +1547,7 @@ def get_annotation_clip(self):
 
     def _get_position_xy(self, renderer):
         """Return the pixel position of the annotated point."""
-        x, y = self.xy
-        return self._get_xy(renderer, x, y, self.xycoords)
+        return self._get_xy(renderer, self.xy, self.xycoords)
 
     def _check_xy(self, renderer=None):
         """Check whether the annotation at *xy_pixel* should be drawn."""

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+Invalid types for Annotation xycoords now raise TypeError`
	`2`	`+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
	`3`	+Previously, a `RuntimeError` would be raised in some cases.