Merge branch 'main' into more_nan_fixes

Author: scottshambaugh

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/asottile/setup-cfg-fmt
-    rev: v2.7.0
+    rev: v2.8.0
     hooks:
     -   id: setup-cfg-fmt
 -   repo: https://github.com/pre-commit/pre-commit-hooks
@@ -13,7 +13,7 @@ repos:
     hooks:
     - id: mypy
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.9
+    rev: v0.11.2
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]

Readme.md

@@ -57,14 +57,15 @@ lines = ax.get_lines()
 l1 = lines[-1]
 labelLine(
     l1,
-    0.6,
+    0.85,
     label=r"$Re=${}".format(l1.get_label()),
-    ha="left",
-    va="bottom",
     align=False,
+    yoffset=0.01,
+    ha="right",
     backgroundcolor="none",
 )
-labelLines(lines[:-1], yoffsets=0.01, align=False, backgroundcolor="none")
+labelLines(lines[:-1], xvals=0.85, yoffsets=0.01, align=False,
+           ha="right", backgroundcolor="none")
 
 # labelLines also supports log-scaled x-axes
 ax = axes[4]

example.png

@@ -1,10 +1,16 @@
 import warnings
 from typing import Optional, Union
-
+from datetime import timedelta
 import matplotlib.pyplot as plt
 import numpy as np
+from datetime import datetime
 from matplotlib.container import ErrorbarContainer
-from matplotlib.dates import DateConverter, num2date
+from matplotlib.dates import (
+    _SwitchableDateConverter,
+    ConciseDateConverter,
+    DateConverter,
+    num2date,
+)
 from matplotlib.lines import Line2D
 from more_itertools import always_iterable
 
@@ -19,6 +25,8 @@ def labelLine(
     label: Optional[str] = None,
     align: Optional[bool] = None,
     drop_label: bool = False,
+    xoffset: float = 0,
+    xoffset_logspace: bool = False,
     yoffset: float = 0,
     yoffset_logspace: bool = False,
     outline_color: str = "auto",
@@ -43,6 +51,11 @@ def labelLine(
     drop_label : bool, optional
        If True, the label is consumed by the function so that subsequent
        calls to e.g. legend do not use it anymore.
+    xoffset : double, optional
+        Space to add to label's x position
+    xoffset_logspace : bool, optional
+        If True, then xoffset will be added to the label's x position in
+        log10 space
     yoffset : double, optional
         Space to add to label's y position
     yoffset_logspace : bool, optional
@@ -65,6 +78,8 @@ def labelLine(
             x,
             label=label,
             align=align,
+            xoffset=xoffset,
+            xoffset_logspace=xoffset_logspace,
             yoffset=yoffset,
             yoffset_logspace=yoffset_logspace,
             outline_color=outline_color,
@@ -97,6 +112,7 @@ def labelLines(
     xvals: Optional[Union[tuple[float, float], list[float]]] = None,
     drop_label: bool = False,
     shrink_factor: float = 0.05,
+    xoffsets: Union[float, list[float]] = 0,
     yoffsets: Union[float, list[float]] = 0,
     outline_color: str = "auto",
     outline_width: float = 5,
@@ -120,6 +136,9 @@ def labelLines(
        calls to e.g. legend do not use it anymore.
     shrink_factor : double, optional
        Relative distance from the edges to place closest labels. Defaults to 0.05.
+    xoffsets : number or list, optional.
+        Distance relative to the line when positioning the labels. If given a number,
+        the same value is used for all lines.
     yoffsets : number or list, optional.
         Distance relative to the line when positioning the labels. If given a number,
         the same value is used for all lines.
@@ -186,18 +205,34 @@ def labelLines(
     if isinstance(xvals, tuple) and len(xvals) == 2:
         xmin, xmax = xvals
         xscale = ax.get_xscale()
+
+        # Convert datetime objects to numeric values for linspace/geomspace
+        x_is_datetime = isinstance(xmin, datetime) or isinstance(xmax, datetime)
+        if x_is_datetime:
+            if not isinstance(xmin, datetime) or not isinstance(xmax, datetime):
+                raise ValueError(
+                    f"Cannot mix datetime and numeric values in xvals: {xvals}"
+                )
+            xmin = plt.matplotlib.dates.date2num(xmin)
+            xmax = plt.matplotlib.dates.date2num(xmax)
+
         if xscale == "log":
             xvals = np.geomspace(xmin, xmax, len(all_lines) + 2)[1:-1]
         else:
             xvals = np.linspace(xmin, xmax, len(all_lines) + 2)[1:-1]
 
+        # Convert numeric values back to datetime objects
+        if x_is_datetime:
+            xvals = plt.matplotlib.dates.num2date(xvals)
+
         # Build matrix line -> xvalue
         ok_matrix = np.zeros((len(all_lines), len(all_lines)), dtype=bool)
 
         for i, line in enumerate(all_lines):
             xdata, _ = normalize_xydata(line)
             minx, maxx = np.nanmin(xdata), np.nanmax(xdata)
             for j, xv in enumerate(xvals):  # type: ignore
+                xv = line.convert_xunits(xv)
                 ok_matrix[i, j] = minx < xv < maxx
 
         # If some xvals do not fall in their corresponding line,
@@ -213,6 +248,8 @@ def labelLines(
             xvals[order] = old_xvals  # type: ignore
     else:
         xvals = list(always_iterable(xvals))  # force the creation of a copy
+        if len(xvals) == 1:
+            xvals = [xvals[0]] * len(all_lines)
 
     lab_lines, labels = [], []
     # Take only the lines which have labels other than the default ones
@@ -224,6 +261,8 @@ def labelLines(
         # Move xlabel if it is outside valid range
         xdata, _ = normalize_xydata(line)
         xmin, xmax = np.nanmin(xdata), np.nanmax(xdata)
+        xv = line.convert_xunits(xv)
+
         if not (xmin <= xv <= xmax):
             warnings.warn(
                 (
@@ -243,20 +282,29 @@ def labelLines(
         converter = ax.xaxis.converter
     else:
         converter = ax.xaxis.get_converter()
-    if isinstance(converter, DateConverter):
+    time_classes = (_SwitchableDateConverter, DateConverter, ConciseDateConverter)
+    if isinstance(converter, time_classes):
         xvals = [
             num2date(x).replace(tzinfo=ax.xaxis.get_units())
             for x in xvals  # type: ignore
         ]
 
     txts = []
+    try:
+        if isinstance(xoffsets, timedelta):
+            xoffsets = [xoffsets] * len(all_lines)  # type: ignore
+        else:
+            xoffsets = [float(xoffsets)] * len(all_lines)  # type: ignore
+    except TypeError:
+        pass
     try:
         yoffsets = [float(yoffsets)] * len(all_lines)  # type: ignore
     except TypeError:
         pass
-    for line, x, yoffset, label in zip(
+    for line, x, xoffset, yoffset, label in zip(
         lab_lines,
         xvals,  # type: ignore
+        xoffsets,  # type: ignore
         yoffsets,  # type: ignore
         labels,
     ):
@@ -267,6 +315,7 @@ def labelLines(
                 label=label,
                 align=align,
                 drop_label=drop_label,
+                xoffset=xoffset,
                 yoffset=yoffset,
                 outline_color=outline_color,
                 outline_width=outline_width,

example/matplotlib_label_lines.ipynb

@@ -2,8 +2,10 @@
 
 from typing import TYPE_CHECKING
 
+import matplotlib.dates as mdates
 import matplotlib.patheffects as patheffects
 import numpy as np
+from datetime import timedelta
 from matplotlib.text import Text
 
 from .utils import normalize_xydata
@@ -35,6 +37,12 @@ class LineLabel(Text):
     _auto_align: bool
     """Align text with the line (True) or parallel to x axis (False)"""
 
+    _xoffset: float
+    """An additional x offset for the label"""
+
+    _xoffset_logspace: bool
+    """Sets whether to treat _xoffset exponentially"""
+
     _yoffset: float
     """An additional y offset for the label"""
 
@@ -56,6 +64,8 @@ def __init__(
         x: Position,
         label: Optional[str] = None,
         align: Optional[bool] = None,
+        xoffset: float = 0,
+        xoffset_logspace: bool = False,
         yoffset: float = 0,
         yoffset_logspace: bool = False,
         outline_color: Optional[Union[AutoLiteral, ColorLike]] = "auto",
@@ -76,6 +86,11 @@ def __init__(
         align : bool, optional
             If true, the label is parallel to the line, otherwise horizontal,
             by default True.
+        xoffset : float, optional
+            An additional x offset for the line label, by default 0.
+        xoffset_logspace : bool, optional
+            If true xoffset is applied exponentially to appear linear on a log-axis,
+            by default False.
         yoffset : float, optional
             An additional y offset for the line label, by default 0.
         yoffset_logspace : bool, optional
@@ -108,6 +123,8 @@ def __init__(
         self._target_x = x
         self._ax = line.axes
         self._auto_align = align
+        self._xoffset = xoffset
+        self._xoffset_logspace = xoffset_logspace
         self._yoffset = yoffset
         self._yoffset_logspace = yoffset_logspace
         label = label or line.get_label()
@@ -162,19 +179,31 @@ def _update_anchors(self):
         x = self._line.convert_xunits(self._target_x)
         xdata, ydata = normalize_xydata(self._line)
 
+        # Convert timedelta to float if needed
+        if isinstance(self._xoffset, timedelta):
+            xoffset = mdates.date2num(self._xoffset + self._target_x) - x
+        else:
+            xoffset = self._xoffset
+
+        # Handle nan values
         mask = np.isfinite(ydata)
         if mask.sum() == 0:
             raise ValueError(f"The line {self._line} only contains nan!")
         xdata = xdata[mask]
         ydata = ydata[mask]
 
-        # Find the first line segment surrounding x
-        for i, (xa, xb) in enumerate(zip(xdata[:-1], xdata[1:])):
-            if min(xa, xb) <= x <= max(xa, xb):
-                ya, yb = ydata[i], ydata[i + 1]
-                break
+        # If the valid data is a single point, then just use that point
+        if len(xdata) == 1:
+            xa, xb = xdata[0], xdata[0]
+            ya, yb = ydata[0], ydata[0]
         else:
-            raise ValueError("x label location is outside data range!")
+            # Find the first line segment surrounding x
+            for i, (xa, xb) in enumerate(zip(xdata[:-1], xdata[1:])):
+                if min(xa, xb) <= x <= max(xa, xb):
+                    ya, yb = ydata[i], ydata[i + 1]
+                    break
+            else:
+                raise ValueError("x label location is outside data range!")
 
         # Interpolate y position of label, (interp needs sorted data)
         if xa != xb:
@@ -185,6 +214,12 @@ def _update_anchors(self):
         else:  # Vertical case
             y = (ya + yb) / 2
 
+        # Apply x offset
+        if self._xoffset_logspace:
+            x *= 10**xoffset
+        else:
+            x += xoffset
+
         # Apply y offset
         if self._yoffset_logspace:
             y *= 10**self._yoffset

labellines/baseline/test_dateaxis_advanced.png

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -164,7 +164,20 @@ def test_dateaxis_advanced(setup_mpl):
     ax.xaxis.set_major_locator(DayLocator())
     ax.xaxis.set_major_formatter(DateFormatter("%Y-%m-%d"))
 
-    labelLines(ax.get_lines())
+    labelLines(ax.get_lines(), xvals=(dates[0], dates[-1]))
+    return plt.gcf()
+
+
+@pytest.mark.mpl_image_compare
+def test_dateaxis_timedelta_xoffset(setup_mpl):
+    dates = [datetime(2018, 11, 1), datetime(2018, 11, 2), datetime(2018, 11, 3)]
+    dt = timedelta(hours=12)
+
+    plt.plot(dates, [0, 1, 2], label="apples")
+    plt.plot(dates, [3, 4, 5], label="banana")
+    ax = plt.gca()
+
+    labelLines(ax.get_lines(), xoffsets=dt)
     return plt.gcf()
 
 
@@ -315,17 +328,22 @@ def test_label_datetime_plot(setup_mpl):
     return plt.gcf()
 
 
-def test_yoffset(setup_mpl):
+def test_xyoffset(setup_mpl):
     x = np.linspace(0, 1)
 
-    for yoffset in ([-0.5, 0.5], 1, 1.2):  # try lists  # try int  # try float
+    for offset in ([-0.5, 0.5], 1, 1.2):  # try lists  # try int  # try float
         plt.clf()
         ax = plt.gca()
         ax.plot(x, np.sin(x) * 10, label=r"$\sin x$")
         ax.plot(x, np.cos(x) * 10, label=r"$\cos x$")
         lines = ax.get_lines()
         labelLines(
-            lines, xvals=(0.2, 0.7), align=False, yoffsets=yoffset, bbox={"alpha": 0}
+            lines,
+            xvals=(0.2, 0.7),
+            xoffsets=offset,
+            yoffsets=offset,
+            align=False,
+            bbox={"alpha": 0},
         )
 
 
@@ -361,6 +379,13 @@ def test_auto_layout(setup_mpl):
     return plt.gcf()
 
 
+@pytest.mark.mpl_image_compare
+def test_single_point_line(setup_mpl):
+    plt.plot(1, 1, label="x")
+    labelLines(plt.gca().get_lines())
+    return plt.gcf()
+
+
 def test_warning_out_of_range():
     X = [0, 1]
     Y = [0, 1]

labellines/baseline/test_dateaxis_timedelta_xoffset.png

@@ -34,7 +34,7 @@ test = [
     "matplotlib==3.10.1",
     "pytest-cov==6.0.0",
     "pytest-mpl==0.17.0",
-    "pytest==8.3.4",
+    "pytest==8.3.5",
 ]
 
 [project.urls]