Subtract datetimes in timesince as 4.1.1 did, then add the offset change

#56 converted the current time to UTC whenever dt.utcoffset() was known.
The subtraction itself asks the tzinfo, not the datetime, so the two could
disagree: a datetime subclass with its own utcoffset() and a tzinfo that
does not know the offset raised TypeError on CPython and was off by the
local UTC offset on PyPy, where 4.1.1 returned the right age.

timesince now subtracts as 4.1.1 did. Only when both datetimes share one
tzinfo, the case where Python ignores the offsets, and that tzinfo knows
both offsets, the change between them is added back. Daylight saving
changes are counted as #56 intended, and every other input gets the
result 4.1.1 gave.

Author: wolph

_python_utils_tests/test_formatters.py

@@ -57,6 +57,41 @@ def test_timesince_aware_datetime(timezone: datetime.timezone) -> None:
     assert formatters.timesince(moment) == '1 hour and 30 minutes ago'
 
 
+class _UnknownOffset(datetime.tzinfo):
+    """A timezone that does not know its UTC offset, as ``tzinfo`` allows."""
+
+    def utcoffset(self, dt: datetime.datetime | None) -> None:
+        """Report the offset as unknown."""
+        return
+
+    def dst(self, dt: datetime.datetime | None) -> None:
+        """Report the daylight saving offset as unknown."""
+        return
+
+    def tzname(self, dt: datetime.datetime | None) -> str:
+        """Name the timezone."""
+        return 'unknown'
+
+    def fromutc(self, dt: datetime.datetime) -> datetime.datetime:
+        """Use the UTC wall clock as the local one."""
+        return dt.replace(tzinfo=self)
+
+
+class _OwnOffsetDateTime(datetime.datetime):
+    """A datetime subclass that reports an offset its tzinfo does not know."""
+
+    def utcoffset(self) -> datetime.timedelta:
+        """Report a fixed offset of three hours."""
+        return datetime.timedelta(hours=3)
+
+
+def test_timesince_datetime_subclass_with_own_offset() -> None:
+    """Subtract a subclass with its own offset the way a datetime does."""
+    age: datetime.timedelta = datetime.timedelta(hours=1, minutes=30)
+    moment: datetime.datetime = _OwnOffsetDateTime.now(_UnknownOffset()) - age
+    assert formatters.timesince(moment) == '1 hour and 30 minutes ago'
+
+
 @pytest.mark.parametrize(
     ('moment', 'current'),
     [

python_utils/formatters.py

@@ -155,14 +155,17 @@ 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))
-        if (
-            getattr(dt, 'tzinfo', None) is not None
-            and dt.utcoffset() is not None
-        ):
-            # Subtraction with the same tzinfo ignores offset changes and fold.
-            # Convert only now: converting dt could overflow near min or max.
-            now = now.astimezone(datetime.timezone.utc)
-        diff = abs(now - dt)
+        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)
 
     # Every unit takes its share from what the larger units left over, so a
     # day is never counted twice.