Keep timesince as 4.1.1 subtracted it outside plain ZoneInfo datetimes

Take back the offset correction of the previous commit. It asked the
tzinfo for both offsets after the subtraction, which counted a DST change
twice for pandas and pendulum values (their own __rsub__ already counts
it), passed arrow.Arrow objects to tzinfo.utcoffset (TypeError, wrong
results, and a segfault in the C zoneinfo on 3.12), and asked tzinfo
shapes for an offset that 4.1.1 never requested.

timesince now subtracts every input as 4.1.1 did, except a plain
datetime whose tzinfo is a zoneinfo.ZoneInfo. For that input it converts
the current time to UTC, as #56 does, so a daylight saving change is
counted. Datetime subclasses, look-alikes such as Arrow, and inputs in
other tzinfo types (dateutil, pytz, custom ones) get the 4.1.1 result,
which for dateutil means the wall-clock difference across a DST change.

Author: wolph

_python_utils_tests/test_formatters.py

@@ -92,6 +92,56 @@ def test_timesince_datetime_subclass_with_own_offset() -> None:
     assert formatters.timesince(moment) == '1 hour and 30 minutes ago'
 
 
+class _WallClockOnly(datetime.tzinfo):
+    """A timezone that only converts from UTC, which ``tzinfo`` allows."""
+
+    def utcoffset(self, dt: datetime.datetime | None) -> datetime.timedelta:
+        """Refuse the offset the way the ``tzinfo`` base class does."""
+        raise NotImplementedError
+
+    def dst(self, dt: datetime.datetime | None) -> datetime.timedelta:
+        """Refuse the daylight saving offset like the base class."""
+        raise NotImplementedError
+
+    def fromutc(self, dt: datetime.datetime) -> datetime.datetime:
+        """Put the local wall clock one hour ahead of UTC."""
+        return (dt + datetime.timedelta(hours=1)).replace(tzinfo=self)
+
+    def tzname(self, dt: datetime.datetime | None) -> str:
+        """Name the timezone."""
+        return 'wall clock'
+
+
+def test_timesince_tzinfo_without_utcoffset() -> None:
+    """Subtract two datetimes in a tzinfo without offsets as 4.1.1 did."""
+    age: datetime.timedelta = datetime.timedelta(hours=1, minutes=30)
+    moment: datetime.datetime = datetime.datetime.now(_WallClockOnly()) - age
+    assert formatters.timesince(moment) == '1 hour and 30 minutes ago'
+
+
+class _LookAlike:
+    """Not a datetime, but subtracts from one, as ``arrow.Arrow`` does."""
+
+    def __init__(self, moment: datetime.datetime) -> None:
+        """Wrap an aware datetime."""
+        self.moment: datetime.datetime = moment
+        self.tzinfo: datetime.tzinfo | None = moment.tzinfo
+
+    def __rsub__(self, other: datetime.datetime) -> datetime.timedelta:
+        """Subtract the wrapped datetime from ``other``."""
+        return other - self.moment
+
+
+def test_timesince_datetime_look_alike() -> None:
+    """Let an object that is not a datetime do its own subtraction."""
+    age: datetime.timedelta = datetime.timedelta(hours=1, minutes=30)
+    # Not one of the documented types, so typed as Any like the date test.
+    moment: typing.Any = _LookAlike(
+        datetime.datetime.now(datetime.timezone.utc) - age
+    )
+    assert formatters.timesince(moment) == '1 hour and 30 minutes ago'
+
+
 @pytest.mark.parametrize(
     ('moment', 'current'),
     [
@@ -148,6 +198,43 @@ def now(cls, tz: datetime.tzinfo | None = None) -> 'FrozenDateTime':
     assert formatters.timesince(moment) == '1 hour ago'
 
 
+class _ElapsedRsub(datetime.datetime):
+    """A subclass whose own subtraction counts elapsed time, as in pandas."""
+
+    def __rsub__(self, other: datetime.datetime) -> datetime.timedelta:
+        """Subtract by UTC timestamp, so a DST change is counted."""
+        seconds: float = other.timestamp() - datetime.datetime.timestamp(self)
+        return datetime.timedelta(seconds=seconds)
+
+
+@pytest.mark.skipif(
+    'America/New_York' not in available_timezones(),
+    reason='IANA timezone data is not available',
+)
+def test_timesince_subclass_subtraction_counts_dst_once(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Leave a subclass that counts elapsed time itself to count it once."""
+    timezone = ZoneInfo('America/New_York')
+    current = datetime.datetime(2026, 11, 1, 1, 30, fold=1, tzinfo=timezone)
+    moment = _ElapsedRsub(2026, 11, 1, 1, 30, fold=0, tzinfo=timezone)
+
+    def frozen_now(tz: datetime.tzinfo | None = None) -> datetime.datetime:
+        """Return the chosen instant as a plain datetime, like the clock."""
+        return datetime.datetime.fromtimestamp(current.timestamp(), tz)
+
+    monkeypatch.setattr(
+        formatters,
+        'datetime',
+        types.SimpleNamespace(
+            datetime=types.SimpleNamespace(now=frozen_now),
+            timedelta=datetime.timedelta,
+            timezone=datetime.timezone,
+        ),
+    )
+    assert formatters.timesince(moment) == '1 hour ago'
+
+
 @pytest.mark.parametrize(
     ('moment', 'expected'),
     [

python_utils/formatters.py

@@ -11,6 +11,7 @@
 # pyright: reportUnnecessaryIsInstance=false
 import collections.abc
 import datetime
+import sys
 import typing
 
 from python_utils import _aliases
@@ -99,6 +100,28 @@ def apply_recursive(
         return data
 
 
+# The class itself, for `_in_zoneinfo_zone`. Code that swaps the module's
+# `datetime` for a stand-in, as tests do, still gets the real class here.
+_DATETIME: typing.Final[type[datetime.datetime]] = datetime.datetime
+
+
+def _in_zoneinfo_zone(dt: object) -> bool:
+    """Tell whether ``dt`` is a plain datetime in a ``zoneinfo`` zone.
+
+    For that input `timesince` counts a daylight saving change. Every other
+    input is subtracted as in 4.1.1: a datetime subclass, a look-alike such
+    as ``arrow.Arrow`` or another tzinfo can do its own subtraction or report
+    its offset in its own way. ``zoneinfo`` is looked up, not imported, since
+    a ``ZoneInfo`` can only exist once that module is loaded.
+    """
+    zoneinfo: typing.Any = sys.modules.get('zoneinfo')
+    return (
+        zoneinfo is not None
+        and type(dt) is _DATETIME
+        and type(getattr(dt, 'tzinfo', None)) is zoneinfo.ZoneInfo
+    )
+
+
 def timesince(
     dt: datetime.datetime | datetime.timedelta,
     default: str = 'just now',
@@ -155,17 +178,13 @@ def timesince(
         # A date has no `tzinfo`, and no time to subtract either. It gets
         # the same `TypeError` from the subtraction as it always did.
         now = datetime.datetime.now(getattr(dt, 'tzinfo', None))
-        diff = now - dt
-        tzinfo: datetime.tzinfo | None = now.tzinfo
-        if tzinfo is not None and tzinfo is dt.tzinfo:
-            # Subtracting two datetimes that share a tzinfo ignores a change
-            # of UTC offset between them, such as a daylight saving change.
-            # Add that change back when the tzinfo knows both offsets.
-            now_offset: datetime.timedelta | None = tzinfo.utcoffset(now)
-            dt_offset: datetime.timedelta | None = tzinfo.utcoffset(dt)
-            if now_offset is not None and dt_offset is not None:
-                diff -= now_offset - dt_offset
-        diff = abs(diff)
+        if _in_zoneinfo_zone(dt):
+            # Two datetimes that share a tzinfo subtract by wall clock, which
+            # misses a daylight saving change between them. The current time
+            # in UTC counts it. Only `now` is converted, because converting
+            # `dt` could overflow near `datetime.min` or `datetime.max`.
+            now = now.astimezone(datetime.timezone.utc)
+        diff = abs(now - dt)
 
     # Every unit takes its share from what the larger units left over, so a
     # day is never counted twice.