Use rounding according to the string format in precisedelta

%d and %0.0f do not produce the same values. So we will first apply the
required formatting and turn the formatted string back into a float or int.

YEARS needs to be treated slightly differently as it needs to be formatted
with `intcomma`. We first check if the resulting value does not have any
fractional part and if not, we turn it into an int, so that it string
output is what a human would expect.

Added several unittests to highlight some of the differences between
using %d and %.0f as a format in precisedelta.

Author: Daniel Gillet

src/humanize/time.py

@@ -603,14 +603,11 @@ def precisedelta(
         ("%d microsecond", "%d microseconds", usecs),
     ]
 
-    import re
-    round_fmt_value = re.fullmatch(r"%\d*(d|(\.0*f))", format)
-
     texts: list[str] = []
     for unit, fmt in zip(reversed(Unit), fmts):
         singular_txt, plural_txt, fmt_value = fmt
-        if round_fmt_value:
-            fmt_value = round(fmt_value)
+
+        fmt_value = _rounding_by_fmt(format, fmt_value)
         if fmt_value > 0 or (not texts and unit == min_unit):
             _fmt_value = 2 if 1 < fmt_value < 2 else int(fmt_value)
             fmt_txt = _ngettext(singular_txt, plural_txt, _fmt_value)
@@ -619,6 +616,8 @@ def precisedelta(
             if unit == min_unit and math.modf(fmt_value)[0] > 0:
                 fmt_txt = fmt_txt.replace("%d", format)
             elif unit == YEARS:
+                if math.modf(fmt_value)[0] == 0:
+                    fmt_value = int(fmt_value)
                 fmt_txt = fmt_txt.replace("%d", "%s")
                 texts.append(fmt_txt % intcomma(fmt_value))
                 continue
@@ -635,3 +634,24 @@ def precisedelta(
     tail = texts[-1]
 
     return _("%s and %s") % (head, tail)
+
+
+def _rounding_by_fmt(format: str, value: float) -> float | int:
+    """Round a number according to the string format provided.
+
+    The string format is the old printf-style String Formatting.
+
+    If we are using a format which truncates the value, such as "%d" or "%i", the
+    returned value will be of type `int`.
+
+    If we are using a format which rounds the value, such as "%.2f" or even "%.0f",
+    we will return a float.
+    """
+    result = format % value
+
+    try:
+        value = int(result)
+    except ValueError:
+        value = float(result)
+
+    return value

tests/test_time.py

@@ -594,7 +594,7 @@ def test_precisedelta_multiple_units(
             "%0.4f",
             "2.0020 milliseconds",
         ),
-        (dt.timedelta(microseconds=2002), "milliseconds", "%0.2f", "2.00 milliseconds"),
+        (dt.timedelta(microseconds=2002), "milliseconds", "%0.2f", "2 milliseconds"),
         (
             dt.timedelta(seconds=1, microseconds=230000),
             "seconds",
@@ -620,18 +620,34 @@ def test_precisedelta_multiple_units(
             "5 days and 4.50 hours",
         ),
         (dt.timedelta(days=5, hours=4, seconds=30 * 60), "days", "%0.2f", "5.19 days"),
+        # 1 month is 30.5 days. Remaining 0.5 days is rounded down for both formats
         (dt.timedelta(days=31), "days", "%d", "1 month"),
-        (dt.timedelta(days=31.01), "days", "%d", "1 month and 1 day"),
+        (dt.timedelta(days=31), "days", "%.0f", "1 month"),
+        # But adding a tiny amount will reveal a difference between %d and %.0f
+        # %d will truncate while %.0f will round to the nearest number.
+        (dt.timedelta(days=31.01), "days", "%d", "1 month"),
+        (dt.timedelta(days=31.01), "days", "%.0f", "1 month and 1 day"),
         (dt.timedelta(days=31.99), "days", "%d", "1 month and 1 day"),
-        (dt.timedelta(days=32), "days", "%d", "1 month and 2 days"),
+        # 1 month is 30.5 days. Remaining 1.5 days is truncated for %d.
+        # For format %.0f, there is a tie, so it's rounded to the nearest even number,
+        # which is 2. See https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules
+        (dt.timedelta(days=32), "days", "%d", "1 month and 1 day"),
+        (dt.timedelta(days=32), "days", "%.0f", "1 month and 2 days"),
         (dt.timedelta(days=62), "days", "%d", "2 months and 1 day"),
         (dt.timedelta(days=92), "days", "%d", "3 months"),
         (dt.timedelta(days=120), "months", "%0.2f", "3.93 months"),
         (dt.timedelta(days=183), "years", "%0.1f", "0.5 years"),
         (0.01, "seconds", "%0.3f", "0.010 seconds"),
-        (31, "minutes", "%d", "1 minute"),
+        # 31 seconds will be truncated to 0 with %d and rounded to the nearest
+        # number with %.0f, ie. 1
+        (31, "minutes", "%d", "0 minutes"),
+        (31, "minutes", "%0.0f", "1 minute"),
         (60 + 29.99, "minutes", "%d", "1 minute"),
-        (60 + 30, "minutes", "%d", "2 minutes"),
+        (60 + 29.99, "minutes", "%.0f", "1 minute"),
+        (60 + 30, "minutes", "%d", "1 minute"),
+        # 30 sec is 0.5 minutes. Round to nearest, ties away from zero.
+        # See https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules
+        (60 + 30, "minutes", "%.0f", "2 minutes"),
         (60 * 60 + 30.99, "minutes", "%.0f", "1 hour"),
         (60 * 60 + 31, "minutes", "%.0f", "1 hour and 1 minute"),
         (
@@ -750,3 +766,20 @@ def test_time_unit() -> None:
 
     with pytest.raises(TypeError):
         _ = years < "foo"
+
+
+@pytest.mark.parametrize(
+    "fmt, value, expected",
+    [
+        ("%.2f", 1.011, 1.01),
+        ("%.0f", 1.01, 1.0),
+        ("%.0f", 1.5, 2.0),
+        ("%10.0f", 1.01, 1.0),
+        ("%i", 1.01, 1),
+        # Surprising rounding with %d. It does not truncate for all values...
+        ("%d", 1.999999999999999, 1),
+        ("%d", 1.9999999999999999, 2),
+    ],
+)
+def test_rounding_by_fmt(fmt: str, value: float, expected: float) -> None:
+    assert time._rounding_by_fmt(fmt, value) == pytest.approx(expected)