Backtestspydanticrun-20260930-144322#13422

Issue #13422 Merged fix PR #13437 Run 30 Sep 2026 · run-20260930-144322 pydantic/pydantic

to_json: timedelta_mode and temporal_mode break documented behavior

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

Patch B fixes the root cause. It restores a separate `timedelta_mode` field on `SerializationConfig`. `temporal_mode` is now always resolved from its own setting. `timedelta_mode` inherits from `temporal_mode` when that is non-default or explicitly set, and otherwise comes from the legacy `timedelta_mode` / `ser_json_timedelta`. The three inference paths (to_python, serialize, JSON key) now read `timedelta_mode` for timedeltas. So `to_json(..., timedelta_mode='float', temporal_mode='iso8601')` yields ISO datetimes/dates/times with float timedeltas, which is the behavior the issue asks for and prefers. Precedence is kept for existing users who set `temporal_mode`/`ser_json_temporal` to a non-default value. B also adds targeted tests covering the exact issue example, the config-based `ser_json_timedelta` path, and dict-key serialization; all would fail before the change. One caveat: B only touches the inference paths, and schema-typed timedelta serializers elsewhere are not shown. Even so, it resolves the reported `to_json`/`to_jsonable_python` scenario. Patch A only rewrites docstrings and changes no behavior. It does not make the documented combination work, and its new text is misleading. It says `temporal_mode` 'takes precedence over `timedelta_mode`', yet under the buggy code `timedelta_mode='float'` overrides `temporal_mode='iso8601'` for all temporal types, which is the reported problem. It also adds no tests. B is clearly better on correctness and tests.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

5m 7s14 turns

Wall-clock time in the container

Full test suite

No new failures

12,262 passed · 501 skipped · 12,763 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

56vs 55 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

pydantic_core.to_json (and to_jsonable_python) documents timedelta_mode and temporal_mode as independent parameters governing disjoint type sets:

  • timedelta_mode: How to serialize timedelta objects, either 'iso8601' or 'float'.
  • temporal_mode: How to serialize datetime-like objects (datetime, date, time), either 'iso8601', 'seconds', or 'milliseconds'.

(This is what both the API docs and the shipped _pydantic_core.pyi type stub say.)

Given that contract, to_json(..., timedelta_mode="float", temporal_mode="iso8601") should serialize datetime/date/time as ISO 8601 strings and timedelta as a float. Instead, datetime/date/time are also coerced to unix-timestamp floats, timedelta_mode="float" silently overrides temporal_mode="iso8601" for all temporal types.

There is no combination of the two parameters that yields ISO datetimes with float-second timedeltas, even though the documented parameters imply there should be.

Root cause / regression. This regressed in #1743. Before that PR, SerializationConfig had a dedicated timedelta_mode: TimedeltaMode field and to_json had no temporal_mode parameter, so timedelta_mode was genuinely independent. #1743 replaced the dedicated field with a single unified temporal_mode and retrofitted timedelta_mode as a legacy alias that maps into it.

Either the docs/.pyi should be corrected to state that timedelta_mode is a deprecated alias that affects all temporal types, or (preferably) timedelta should retain an independent setting so the documented behavior holds. Personally I have a requirement to be able to set the timedelta format independent of the other datetime types.

Example Code

import datetime
import pydantic_core

payload = {
    "dt": datetime.datetime(2026, 7, 9, 12, 0, 0),
    "d": datetime.date(2026, 7, 9),
    "t": datetime.time(12, 0, 0),
    "td": datetime.timedelta(hours=1, minutes=30),
}

# Per the docs: temporal_mode governs dt/d/t; timedelta_mode governs td.
actual = pydantic_core.to_json(
    payload, timedelta_mode="float", temporal_mode="iso8601"
).decode()

expected = '{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}'

print("actual  :", actual)
print("expected:", expected)
assert actual == expected, "timedelta_mode='float' wrongly coerced datetime/date/time to floats"
# AssertionError: actual == {"dt":1783598400.0,"d":1783555200.0,"t":43200.0,"td":5400.0}

Python, Pydantic & OS Version

pydantic version: 2.13.4
        pydantic-core version: 2.46.4
          pydantic-core build: profile=release pgo=false
               python version: 3.11.14 (main, Oct 10 2025, 12:48:11) [Clang 20.1.4 ]
                     platform: Linux-6.17.0-35-generic-x86_64-with-glibc2.39
             related packages: typing_extensions-4.16.0 mypy-2.2.0 email-validator-2.3.0 pydantic-settings-2.14.2 pydantic-extra-types-2.11.1
                       commit: unknown

The two patches

Our patch+49 −7
pydantic-core/src/serializers/config.rsindex 9a1377c6..f972d286 100644@@ -22,6 +22,7 @@ use super::errors::py_err_se_err; #[allow(clippy::struct_field_names)] pub(crate) struct SerializationConfig {     pub temporal_mode: TemporalMode,+    pub timedelta_mode: TemporalMode,     pub bytes_mode: BytesMode,     pub inf_nan_mode: InfNanMode, }@@ -30,6 +31,7 @@ impl Default for SerializationConfig {     fn default() -> Self {         Self {             temporal_mode: TemporalMode::default(),+            timedelta_mode: TemporalMode::default(),             bytes_mode: BytesMode::default(),             inf_nan_mode: InfNanMode::Constants,         }@@ -41,8 +43,9 @@ impl SerializationConfig {         let temporal_set = config             .and_then(|cfg| cfg.contains(intern!(cfg.py(), "ser_json_temporal")).ok())             .unwrap_or(false);-        let temporal_mode = if temporal_set {-            TemporalMode::from_config(config)?+        let temporal_mode = TemporalMode::from_config(config)?;+        let timedelta_mode = if temporal_set {+            temporal_mode         } else {             TimedeltaMode::from_config(config)?.into()         };@@ -50,6 +53,7 @@ impl SerializationConfig {         let inf_nan_mode = InfNanMode::from_config(config)?;         Ok(Self {             temporal_mode,+            timedelta_mode,             bytes_mode,             inf_nan_mode,         })@@ -61,13 +65,15 @@ impl SerializationConfig {         bytes_mode: &str,         inf_nan_mode: &str,     ) -> PyResult<Self> {-        let resolved_temporal_mode = if temporal_mode != "iso8601" {-            TemporalMode::from_str(temporal_mode)?+        let resolved_temporal_mode = TemporalMode::from_str(temporal_mode)?;+        let resolved_timedelta_mode = if temporal_mode != "iso8601" {+            resolved_temporal_mode         } else {             TimedeltaMode::from_str(timedelta_mode)?.into()         };         Ok(Self {             temporal_mode: resolved_temporal_mode,+            timedelta_mode: resolved_timedelta_mode,             bytes_mode: BytesMode::from_str(bytes_mode)?,             inf_nan_mode: InfNanMode::from_str(inf_nan_mode)?,         })pydantic-core/src/serializers/infer.rsindex 141a4d5f..f8aaccf9 100644@@ -164,7 +164,7 @@ pub(crate) fn infer_to_python_known<'py>(             }             ObType::Timedelta => {                 let either_delta = EitherTimedelta::try_from(value)?;-                state.config.temporal_mode.timedelta_to_json(value.py(), either_delta)?+                state.config.timedelta_mode.timedelta_to_json(value.py(), either_delta)?             }             ObType::Url             | ObType::MultiHostUrl@@ -412,7 +412,7 @@ pub(crate) fn infer_serialize_known<'py, S: Serializer>(         }         ObType::Timedelta => {             let either_delta = EitherTimedelta::try_from(value).map_err(py_err_se_err)?;-            state.config.temporal_mode.timedelta_serialize(either_delta, serializer)+            state.config.timedelta_mode.timedelta_serialize(either_delta, serializer)         }         ObType::Url         | ObType::MultiHostUrl@@ -538,7 +538,7 @@ pub(crate) fn infer_json_key_known<'a, 'py>(         }         ObType::Timedelta => {             let either_delta = EitherTimedelta::try_from(key)?;-            state.config.temporal_mode.timedelta_json_key(&either_delta)+            state.config.timedelta_mode.timedelta_json_key(&either_delta)         }         ObType::Url         | ObType::MultiHostUrlpydantic-core/tests/serializers/test_any.pyindex 3d2ca39f..3d8b9062 100644@@ -456,6 +456,42 @@ def test_encoding(any_serializer, gen_input, kwargs, expected_json):         assert any_serializer.to_python(gen_input(), mode='json') == json.loads(expected_json)  +TEMPORAL_PAYLOAD = {+    'dt': datetime(2026, 7, 9, 12, 0, 0),+    'd': date(2026, 7, 9),+    't': time(12, 0, 0),+    'td': timedelta(hours=1, minutes=30),+}+TEMPORAL_PAYLOAD_JSON = {'dt': '2026-07-09T12:00:00', 'd': '2026-07-09', 't': '12:00:00', 'td': 5400.0}+++def test_timedelta_mode_float_does_not_affect_other_temporal_types():+    """`timedelta_mode` should only affect `timedelta`, not `datetime`/`date`/`time`."""+    assert (+        to_json(TEMPORAL_PAYLOAD, timedelta_mode='float', temporal_mode='iso8601')+        == b'{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}'+    )+    assert (+        pydantic_core.to_jsonable_python(TEMPORAL_PAYLOAD, timedelta_mode='float', temporal_mode='iso8601')+        == TEMPORAL_PAYLOAD_JSON+    )+++def test_ser_json_timedelta_float_config_does_not_affect_other_temporal_types():+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})+    assert s.to_json(TEMPORAL_PAYLOAD) == b'{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}'+    assert s.to_python(TEMPORAL_PAYLOAD, mode='json') == TEMPORAL_PAYLOAD_JSON+++def test_timedelta_mode_float_does_not_affect_other_temporal_dict_keys():+    payload = {datetime(2026, 7, 9, 12, 0, 0): 1, timedelta(hours=1, minutes=30): 2}+    assert to_json(payload, timedelta_mode='float', temporal_mode='iso8601') == b'{"2026-07-09T12:00:00":1,"5400":2}'+    assert pydantic_core.to_jsonable_python(payload, timedelta_mode='float', temporal_mode='iso8601') == {+        '2026-07-09T12:00:00': 1,+        '5400': 2,+    }++ def test_any_dataclass():     @dataclasses.dataclass     class Foo: 
Merged fix · PR #13437+49 −6
pydantic-core/python/pydantic_core/_pydantic_core.pyiindex c13dd4d21..12b8e4d49 100644@@ -449,10 +449,31 @@ def to_json(         by_alias: Whether to use the alias names of fields.         exclude_none: Whether to exclude fields that have a value of `None`.         round_trip: Whether to enable serialization and validation round-trip support.-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.-        temporal_mode: How to serialize datetime-like objects (`datetime`, `date`, `time`), either `'iso8601'`, `'seconds'`, or `'milliseconds'`.-            `iso8601` returns an ISO 8601 string; `seconds` returns the Unix timestamp in seconds as a float; `milliseconds` returns the Unix timestamp in milliseconds as a float.+        timedelta_mode: The format of serialized timedeltas. Accepts the string values of `'iso8601'` and `'float'`. +            - `'iso8601'` will serialize timedeltas to [ISO 8601 text format](https://en.wikipedia.org/wiki/ISO_8601#Durations).+            - `'float'` will serialize timedeltas to the total number of seconds.++            /// version-changed | v2.12+            It is now recommended to use the `temporal_mode` argument. `timedelta_mode` will be deprecated in v3.+            ///+        temporal_mode: The format of serialized temporal types from the [`datetime`][] module. This includes:++            - [`datetime.datetime`][]+            - [`datetime.date`][]+            - [`datetime.time`][]+            - [`datetime.timedelta`][]++            Can be one of:++            - `'iso8601'` will serialize date-like types to [ISO 8601 text format](https://en.wikipedia.org/wiki/ISO_8601#Durations).+            - `'milliseconds'` will serialize date-like types to a floating point number of milliseconds since the epoch.+            - `'seconds'` will serialize date-like types to a floating point number of seconds since the epoch.++            /// version-added | v2.12+            This argument replaces `timedelta_mode`, which will be deprecated in v3. `temporal_mode` adds more+            configurability for the other temporal types. It takes precedence over `timedelta_mode`.+            ///         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails@@ -534,10 +555,31 @@ def to_jsonable_python(         by_alias: Whether to use the alias names of fields.         exclude_none: Whether to exclude fields that have a value of `None`.         round_trip: Whether to enable serialization and validation round-trip support.-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.-        temporal_mode: How to serialize datetime-like objects (`datetime`, `date`, `time`), either `'iso8601'`, `'seconds'`, or `'milliseconds'`.-            `iso8601` returns an ISO 8601 string; `seconds` returns the Unix timestamp in seconds as a float; `milliseconds` returns the Unix timestamp in milliseconds as a float.+        timedelta_mode: The format of serialized timedeltas. Accepts the string values of `'iso8601'` and `'float'`.++            - `'iso8601'` will serialize timedeltas to [ISO 8601 text format](https://en.wikipedia.org/wiki/ISO_8601#Durations).+            - `'float'` will serialize timedeltas to the total number of seconds.++            /// version-changed | v2.12+            It is now recommended to use the `temporal_mode` argument. `timedelta_mode` will be deprecated in v3.+            ///+        temporal_mode: The format of serialized temporal types from the [`datetime`][] module. This includes:++            - [`datetime.datetime`][]+            - [`datetime.date`][]+            - [`datetime.time`][]+            - [`datetime.timedelta`][]++            Can be one of:++            - `'iso8601'` will serialize date-like types to [ISO 8601 text format](https://en.wikipedia.org/wiki/ISO_8601#Durations).+            - `'milliseconds'` will serialize date-like types to a floating point number of milliseconds since the epoch.+            - `'seconds'` will serialize date-like types to a floating point number of seconds since the epoch. +            /// version-added | v2.12+            This argument replaces `timedelta_mode`, which will be deprecated in v3. `temporal_mode` adds more+            configurability for the other temporal types. It takes precedence over `timedelta_mode`.+            ///         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that failspydantic/config.pyindex 5211aae83..e61029bdf 100644@@ -595,6 +595,7 @@ class ConfigDict(TypedDict, total=False):     /// version-added | v2.12     This setting replaces [`ser_json_timedelta`][pydantic.config.ConfigDict.ser_json_timedelta],     which will be deprecated in v3. `ser_json_temporal` adds more configurability for the other temporal types.+    It takes precedence over `ser_json_timedelta`.     ///     """  

What the agent reported

I fixed it: timedelta_mode now affects only timedelta values, and datetime/date/time follow temporal_mode alone. The report's example now prints the expected output, and the targeted tests pass.

What was wrong. Since #1743, SerializationConfig in pydantic-core/src/serializers/config.rs held one temporal_mode for every temporal type. from_args (behind to_json/to_jsonable_python) converted timedelta_mode into that shared mode whenever temporal_mode was 'iso8601', so timedelta_mode='float' made all temporal types floats. from_config did the same with ser_json_timedelta when ser_json_temporal wasn't set. That second path hit untyped (any_schema) values, so config-driven serialization had the same bug. Typed fields were already correct, because the dedicated timedelta serializer has its own setting.

What I changed (all uncommitted):

  • config.rs: added a separate timedelta_mode field to SerializationConfig. datetime/date/time now use only temporal_mode (or ser_json_temporal). For timedeltas, a temporal_mode other than 'iso8601', or ser_json_temporal in config, still takes priority as it did before; otherwise timedelta_mode/ser_json_timedelta applies. This matches the typed timedelta serializer (type_serializers/timedelta.rs).
  • infer.rs: the three timedelta code paths (Python/JSON-mode output, direct JSON output, dict keys) now read the new field.
  • Tests: three new tests in pydantic-core/tests/serializers/test_any.py:
  • test_timedelta_mode_float_does_not_affect_other_temporal_types is the report's exact example through to_json and to_jsonable_python.
  • test_ser_json_timedelta_float_config_does_not_affect_other_temporal_types covers the any_schema config path.
  • test_timedelta_mode_float_does_not_affect_other_temporal_dict_keys covers datetime and timedelta dict keys.

Test evidence:

  • Before the fix: I reproduced the bug (b'{"dt":1783598400.0,"td":5400.0}'). The test-writer built the unmodified code in a temporary worktree and all 3 new tests failed with datetimes as floats. That worktree has been removed.
  • After the fix: I rebuilt the extension (maturin develop --uv). The example prints {"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}.
  • ./bt-test pydantic-core/tests/serializers pydantic-core/tests/test_json.py: 854 passed, 5 skipped, 1 xfailed, including the 3 new tests.
  • ./bt-test tests/test_json.py tests/test_datetime.py tests/test_serialize.py tests/test_json_schema.py: 911 passed, 4 skipped, 1 xfailed.
  • Not run: cargo fmt and cargo clippy, because those components aren't installed. The code compiles cleanly.

Blast radius. Before the fix, ser_json_timedelta='float' also made untyped (Any) datetimes into floats in config-driven serialization. That combination now gives ISO strings, which is the documented behavior. The existing timedelta, datetime, Any and JSON tests all pass.

Requirements:

  1. timedelta_mode='float' with temporal_mode='iso8601' gives ISO datetime/date/time and a float timedelta: done, covered by the first test.
  2. A way to set the timedelta format independently of other temporal types: done for to_json/to_jsonable_python and for config on Any values; typed fields were already independent. Covered by the first two tests.
  3. Report's alternative, correcting the docs to call timedelta_mode a deprecated alias: not done, because the preferred option was implemented. The .pyi wording (lines 452 and 537) already describes the new behavior, so no doc change was needed.
  4. Behaviour not in the docs: a temporal_mode of 'seconds' or 'milliseconds' still applies to timedeltas as well. I kept it so existing callers don't break. No test covers it; I didn't add one because it would pass both before and after the change.