fix(python): derive DateTime "O" format from the value, not the host timezone (#4869)

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dbrattli

src/fable-library-py/fable_library/date.py

@@ -456,6 +456,52 @@ def date_to_string_with_custom_format(date: datetime, format: str, utc: bool) ->
     return result
 
 
+def _is_date_time_offset(date: datetime) -> bool:
+    # DateTimeOffset sets this marker on itself. It is checked by attribute
+    # rather than isinstance because date_offset imports this module, so
+    # importing it back here would be a cycle.
+    return getattr(date, "is_offset_value", False) is True
+
+
+def _offset_designator(offset: timedelta) -> str:
+    """Format a UTC offset the way .NET's "zzz" does: "+02:00", "-05:30"."""
+    total_minutes = round(offset.total_seconds() / 60)
+    sign = "-" if total_minutes < 0 else "+"
+    total_minutes = abs(total_minutes)
+    return f"{sign}{total_minutes // 60:02d}:{total_minutes % 60:02d}"
+
+
+def _roundtrip_zone_designator(date: datetime) -> str:
+    """Zone designator of the round-trip format, derived from the value alone.
+
+    Kind = Unspecified has none, Kind = Utc is "Z", and Kind = Local carries its
+    own offset. A DateTimeOffset always prints a numeric offset, even "+00:00".
+    """
+    offset = date.utcoffset()
+    if offset is None:
+        return ""
+
+    if date.tzinfo == UTC and not _is_date_time_offset(date):
+        return "Z"
+
+    return _offset_designator(offset)
+
+
+def _to_roundtrip_string(date: datetime) -> str:
+    """Round-trip ("O"/"o") format: "yyyy-MM-ddTHH:mm:ss.fffffff" plus a zone
+    designator.
+
+    The result depends only on the value, never on the host timezone. Python's
+    datetime only carries microseconds, so the seventh fractional digit is
+    always 0 rather than truncating the fraction to six digits.
+    """
+    return (
+        f"{date.year:04d}-{date.month:02d}-{date.day:02d}"
+        f"T{date.hour:02d}:{date.minute:02d}:{date.second:02d}"
+        f".{date.microsecond:06d}0{_roundtrip_zone_designator(date)}"
+    )
+
+
 def date_to_string_with_offset(date: datetime, format: str | None = None) -> str:
     utc = date.tzinfo == UTC
 
@@ -467,7 +513,7 @@ def date_to_string_with_offset(date: datetime, format: str | None = None) -> str
             else:
                 return date.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
         case "O" | "o":
-            return date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            return _to_roundtrip_string(date)
         case "D":
             return to_long_date_string(date)
         case "d":
@@ -524,7 +570,7 @@ def date_to_string_with_kind(date: datetime, format: str | None = None) -> str:
         case "M" | "m":
             return to_month_day_string(date)
         case "O" | "o":
-            return date.astimezone().isoformat(timespec="milliseconds")
+            return _to_roundtrip_string(date)
         case "R" | "r":
             return to_rfc1123_string(date)
         case "s":

src/fable-library-py/fable_library/date_offset.py

@@ -14,6 +14,11 @@
 class DateTimeOffset(datetime):
     """A datetime subclass with an explicit offset, similar to .NET DateTimeOffset"""
 
+    # Lets the formatters in `date` tell a DateTimeOffset apart from a DateTime
+    # with Kind = Utc — a zero offset gives both the same tzinfo, but only the
+    # latter renders as "Z" in the round-trip format.
+    is_offset_value: bool = True
+
     def __new__(cls, dt: datetime, offset_milliseconds: int = 0):
         # Create new datetime instance using the values from the input datetime
         instance = super().__new__(

tests/Python/TestDateTime.fs

@@ -542,19 +542,57 @@ let ``test DateTime.ToString("t") (lower) works`` () =
 
 [<Fact>]
 let ``test DateTime.ToString with Round-trip format works for Utc`` () =
-    let str = DateTime(2014, 9, 11, 16, 37, 2, DateTimeKind.Utc).ToString("O")
-    // FIXME: missing regex module
-    // System.Text.RegularExpressions.Regex.Replace(str, "0{3,}", "000")
-    // Hardcode the replace string so we can test that "O" format is supported
-    str.Replace("0000000Z", "000000Z")
-    |> equal "2014-09-11T16:37:02.000000Z"
-
-    let str = DateTime(2014, 9, 11, 16, 37, 2, DateTimeKind.Utc).ToString("o")
-    // FIXME: missing regex module
-    // System.Text.RegularExpressions.Regex.Replace(str, "0{3,}", "000")
-    // Hardcode the replace string so we can test that "O" format is supported
-    str.Replace("0000000Z", "000000Z")
-    |> equal "2014-09-11T16:37:02.000000Z"
+    DateTime(2014, 9, 11, 16, 37, 2, DateTimeKind.Utc).ToString("O")
+    |> equal "2014-09-11T16:37:02.0000000Z"
+
+    DateTime(2014, 9, 11, 16, 37, 2, DateTimeKind.Utc).ToString("o")
+    |> equal "2014-09-11T16:37:02.0000000Z"
+
+[<Fact>]
+let ``test DateTime.ToString with Round-trip format works for Unspecified`` () =
+    // The round-trip format must depend only on the value: an Unspecified
+    // DateTime carries no offset, so none is printed whatever the host timezone.
+    DateTime(2014, 9, 11, 16, 37, 2).ToString("O")
+    |> equal "2014-09-11T16:37:02.0000000"
+
+    DateTime(2014, 9, 11, 16, 37, 2, 345).ToString("o")
+    |> equal "2014-09-11T16:37:02.3450000"
+
+[<Fact>]
+let ``test DateTime.ToString with Round-trip format works for Local`` () =
+    // A Local DateTime prints its own offset, which follows the host timezone,
+    // so only the machine-independent part can be asserted literally.
+    let str = DateTime(2014, 9, 11, 16, 37, 2, DateTimeKind.Local).ToString("O")
+    str.Substring(0, 27) |> equal "2014-09-11T16:37:02.0000000"
+    str.Length |> equal 33
+    let sign = str.[27]
+    (sign = '+' || sign = '-') |> equal true
+    str.[30] |> equal ':'
+
+[<Fact>]
+let ``test DateTime.ToString with Round-trip format pads the fraction to 7 digits`` () =
+    // Sub-millisecond digits are padded on the right, not truncated.
+    DateTime(2014, 9, 11, 16, 37, 2, 345, DateTimeKind.Utc).ToString("O")
+    |> equal "2014-09-11T16:37:02.3450000Z"
+
+    DateTime(2014, 9, 11, 16, 37, 2, 345, 678, DateTimeKind.Utc).ToString("O")
+    |> equal "2014-09-11T16:37:02.3456780Z"
+
+[<Fact>]
+let ``test DateTime.ToString with Round-trip format round-trips the instant`` () =
+    let roundtrips (d: DateTime) =
+        let parsed = DateTime.Parse(d.ToString("O"), CultureInfo.InvariantCulture)
+        parsed.ToUniversalTime() |> equal (d.ToUniversalTime())
+
+    roundtrips (DateTime(2014, 9, 11, 16, 37, 2, 345))
+    roundtrips (DateTime(2014, 9, 11, 16, 37, 2, 345, DateTimeKind.Utc))
+    roundtrips (DateTime(2014, 9, 11, 16, 37, 2, 345, DateTimeKind.Local))
+
+    // An Unspecified value has no offset to interpret, so its Kind survives too
+    let unspecified = DateTime(2014, 9, 11, 16, 37, 2, 345)
+    let parsed = DateTime.Parse(unspecified.ToString("O"), CultureInfo.InvariantCulture)
+    parsed.Kind |> equal DateTimeKind.Unspecified
+    parsed |> equal unspecified
 
 [<Fact>]
 let ``test DateTime.ToString("R") works`` () =

tests/Python/TestDateTimeOffset.fs

@@ -489,6 +489,26 @@ let ``test DateTimeOffset.ToString with custom format works`` () =
     DateTimeOffset(2014, 9, 11, 16, 37, 0, TimeSpan.Zero).ToString("HH:mm", CultureInfo.InvariantCulture)
     |> equal "16:37"
 
+[<Fact>]
+let ``test DateTimeOffset.ToString with Round-trip format works`` () =
+    // A DateTimeOffset always prints its own numeric offset — even "+00:00",
+    // where a DateTime with Kind = Utc would print "Z" instead.
+    DateTimeOffset(2014, 9, 11, 16, 37, 2, TimeSpan.FromHours 2).ToString("O", CultureInfo.InvariantCulture)
+    |> equal "2014-09-11T16:37:02.0000000+02:00"
+
+    DateTimeOffset(2014, 9, 11, 16, 37, 2, TimeSpan.Zero).ToString("o", CultureInfo.InvariantCulture)
+    |> equal "2014-09-11T16:37:02.0000000+00:00"
+
+    DateTimeOffset(2014, 9, 11, 16, 37, 2, 345, TimeSpan.FromMinutes -330.0).ToString("O", CultureInfo.InvariantCulture)
+    |> equal "2014-09-11T16:37:02.3450000-05:30"
+
+[<Fact>]
+let ``test DateTimeOffset.ToString with Round-trip format round-trips`` () =
+    let d = DateTimeOffset(2014, 9, 11, 16, 37, 2, 345, TimeSpan.FromHours 2)
+    let parsed = DateTimeOffset.Parse(d.ToString("O", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture)
+    parsed |> equal d
+    parsed.Offset |> equal d.Offset
+
 [<Fact>]
 let ``test DateTimeOffset.ToString("R") works`` () =
     // R always formats in UTC