Backtestspydanticrun-20260930-183947#13422

Issue #13422 Merged fix PR #13437 Run 30 Sep 2026 · run-20260930-183947 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 adds a separate `timedelta_mode` field to `SerializationConfig`, so legacy `timedelta_mode` / `ser_json_timedelta` affects only timedeltas. It routes the inferred (any) serialization paths (to_python, serialize, json_key) through that field. It also consolidates the resolution logic in `TemporalMode::timedelta_from_config`, which the dedicated `TimeDeltaSerializer` shares. With the issue's call `to_json(..., timedelta_mode='float', temporal_mode='iso8601')`, datetime/date/time stay ISO 8601 and the timedelta becomes 5400.0, which is the documented behavior. A non-default `temporal_mode` still overrides timedeltas for backward compatibility, and the .pyi docs are updated to say so. B adds targeted tests at both levels: pydantic-core (`to_json`, `to_jsonable_python`, SchemaSerializer config, dict keys) and pydantic (`ConfigDict(ser_json_timedelta='float')` with typed and `Any` fields). These tests would fail before the change. Patch A only rewrites docstrings and does not change the behavior. Its new text says `timedelta_mode` serializes timedeltas while `temporal_mode` takes precedence, but in the issue's scenario the code still coerces datetimes to floats. The docs remain inaccurate, and the user's requirement for an independent timedelta format goes unmet. A 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

13m 10s

Wall-clock time in the container

Full test suite

No new failures

12,266 passed · 501 skipped · 12,767 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

152vs 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+126 −26
pydantic-core/python/pydantic_core/_pydantic_core.pyiindex c13dd4d2..daf67f23 100644@@ -450,8 +450,10 @@ def to_json(         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'`.+            Ignored if `temporal_mode` is set to a value other than `'iso8601'`.         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.+            If set to a value other than `'iso8601'`, it also applies to `timedelta` objects, taking 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'`.@@ -535,8 +537,10 @@ def to_jsonable_python(         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'`.+            Ignored if `temporal_mode` is set to a value other than `'iso8601'`.         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.+            If set to a value other than `'iso8601'`, it also applies to `timedelta` objects, taking 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'`.pydantic-core/src/serializers/config.rsindex 9a1377c6..6277c223 100644@@ -21,7 +21,11 @@ use super::errors::py_err_se_err; #[derive(Debug, Clone, Copy)] #[allow(clippy::struct_field_names)] pub(crate) struct SerializationConfig {+    /// Mode for `datetime`, `date` and `time` values.     pub temporal_mode: TemporalMode,+    /// Mode for `timedelta` values, resolved separately so that the legacy `timedelta_mode` /+    /// `ser_json_timedelta` setting only affects timedeltas.+    pub timedelta_mode: TemporalMode,     pub bytes_mode: BytesMode,     pub inf_nan_mode: InfNanMode, }@@ -30,6 +34,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,         }@@ -38,18 +43,13 @@ impl Default for SerializationConfig {  impl SerializationConfig {     pub fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {-        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)?-        } else {-            TimedeltaMode::from_config(config)?.into()-        };+        let temporal_mode = TemporalMode::from_config(config)?;+        let timedelta_mode = TemporalMode::timedelta_from_config(config)?;         let bytes_mode = BytesMode::from_config(config)?;         let inf_nan_mode = InfNanMode::from_config(config)?;         Ok(Self {             temporal_mode,+            timedelta_mode,             bytes_mode,             inf_nan_mode,         })@@ -61,13 +61,17 @@ 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 temporal_mode = TemporalMode::from_str(temporal_mode)?;+        let legacy_timedelta_mode = TimedeltaMode::from_str(timedelta_mode)?;+        // A non-default `temporal_mode` also governs timedeltas; otherwise `timedelta_mode` applies.+        let timedelta_mode = if temporal_mode == TemporalMode::Iso8601 {+            legacy_timedelta_mode.into()         } else {-            TimedeltaMode::from_str(timedelta_mode)?.into()+            temporal_mode         };         Ok(Self {-            temporal_mode: resolved_temporal_mode,+            temporal_mode,+            timedelta_mode,             bytes_mode: BytesMode::from_str(bytes_mode)?,             inf_nan_mode: InfNanMode::from_str(inf_nan_mode)?,         })@@ -158,6 +162,20 @@ impl From<TimedeltaMode> for TemporalMode { }  impl TemporalMode {+    /// Resolve the mode used for `timedelta` values: `ser_json_temporal` if set,+    /// otherwise the legacy `ser_json_timedelta` setting.+    pub fn timedelta_from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {+        let temporal_set = match config {+            Some(cfg) => cfg.contains(intern!(cfg.py(), "ser_json_temporal"))?,+            None => false,+        };+        if temporal_set {+            Self::from_config(config)+        } else {+            Ok(TimedeltaMode::from_config(config)?.into())+        }+    }+     pub fn datetime_to_json(self, py: Python, datetime: &Bound<'_, PyDateTime>) -> PyResult<Py<PyAny>> {         let dt = pydatetime_as_datetime(datetime)?;         match self {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/src/serializers/type_serializers/timedelta.rsindex b866bf2e..2a142ed2 100644@@ -1,4 +1,3 @@-use pyo3::intern; use pyo3::prelude::*; use pyo3::types::PyDict; use std::borrow::Cow;@@ -7,7 +6,7 @@ use std::sync::Arc; use crate::definitions::DefinitionsBuilder; use crate::input::EitherTimedelta; use crate::serializers::SerializationState;-use crate::serializers::config::{FromConfig, TemporalMode, TimedeltaMode};+use crate::serializers::config::TemporalMode;  use super::{     BuildSerializer, CombinedSerializer, SerMode, TypeSerializer, infer_json_key, infer_serialize, infer_to_python,@@ -26,15 +25,7 @@ impl BuildSerializer for TimeDeltaSerializer {         config: Option<&Bound<'_, PyDict>>,         _definitions: &mut DefinitionsBuilder<Arc<CombinedSerializer>>,     ) -> PyResult<Arc<CombinedSerializer>> {-        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)?-        } else {-            let td_mode = TimedeltaMode::from_config(config)?;-            td_mode.into()-        };+        let temporal_mode = TemporalMode::timedelta_from_config(config)?;          Ok(Arc::new(Self { temporal_mode }.into()))     }pydantic-core/tests/serializers/test_any.pyindex 3d2ca39f..37b396b9 100644@@ -209,6 +209,63 @@ def test_any_config_timedelta_float_faction():     assert s.to_json({one_half_s: 'foo'}) == b'{"1.5":"foo"}'  +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),+}+++def test_any_config_timedelta_float_leaves_other_temporal_types_iso8601():+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})+    assert s.to_python(TEMPORAL_PAYLOAD, mode='json') == {+        'dt': '2026-07-09T12:00:00',+        'd': '2026-07-09',+        't': '12:00:00',+        'td': 5400.0,+    }+    assert s.to_json(TEMPORAL_PAYLOAD) == b'{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}'++    keys = {datetime(2026, 7, 9, 12, 0, 0): 1, date(2026, 7, 9): 2, time(12, 0, 0): 3, timedelta(seconds=90): 4}+    assert s.to_python(keys, mode='json') == {'2026-07-09T12:00:00': 1, '2026-07-09': 2, '12:00:00': 3, '90': 4}+    assert s.to_json(keys) == b'{"2026-07-09T12:00:00":1,"2026-07-09":2,"12:00:00":3,"90":4}'+++def test_any_config_temporal_overrides_timedelta():+    s = SchemaSerializer(+        core_schema.any_schema(), config={'ser_json_timedelta': 'float', 'ser_json_temporal': 'iso8601'}+    )+    assert s.to_json(TEMPORAL_PAYLOAD) == (+        b'{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":"PT1H30M"}'+    )+++@pytest.mark.parametrize('func', [to_json, pydantic_core.to_jsonable_python])+def test_timedelta_mode_float_with_temporal_mode_iso8601(func):+    expected = {'dt': '2026-07-09T12:00:00', 'd': '2026-07-09', 't': '12:00:00', 'td': 5400.0}+    result = func(TEMPORAL_PAYLOAD, timedelta_mode='float', temporal_mode='iso8601')+    if func is to_json:+        assert result == b'{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}'+    else:+        assert result == expected+    # same result when `temporal_mode` is left at its default+    assert func(TEMPORAL_PAYLOAD, timedelta_mode='float') == result++    keys = {datetime(2026, 7, 9, 12, 0, 0): 1, timedelta(seconds=90): 2}+    if func is to_json:+        assert func(keys, timedelta_mode='float') == b'{"2026-07-09T12:00:00":1,"90":2}'+    else:+        assert func(keys, timedelta_mode='float') == {'2026-07-09T12:00:00': 1, '90': 2}+++@pytest.mark.parametrize('timedelta_mode', ['iso8601', 'float'])+def test_non_default_temporal_mode_applies_to_timedelta(timedelta_mode):+    assert pydantic_core.to_jsonable_python(+        TEMPORAL_PAYLOAD, timedelta_mode=timedelta_mode, temporal_mode='milliseconds'+    ) == {'dt': 1783598400000.0, 'd': 1783555200000.0, 't': 43200000.0, 'td': 5400000.0}++ def test_recursion(any_serializer):     v = [1, 2]     v.append(v)tests/test_json.pyindex ef5c98fa..85df0d0e 100644@@ -188,6 +188,36 @@ def test_subclass_custom_encoding():     assert m.model_dump_json() == '{"a":"Thu, 01 Jan 20 01:01:00","b":360000.0}'  +def test_ser_json_timedelta_float_does_not_affect_other_temporal_types():+    class Model(BaseModel):+        dt: datetime+        d: date+        t: time+        td: timedelta+        any_value: Any++        model_config = ConfigDict(ser_json_timedelta='float')++    m = Model(+        dt=datetime(2026, 7, 9, 12),+        d=date(2026, 7, 9),+        t=time(12),+        td=timedelta(hours=1, minutes=30),+        any_value=[datetime(2026, 7, 9, 12), timedelta(hours=1, minutes=30)],+    )+    assert m.model_dump(mode='json') == {+        'dt': '2026-07-09T12:00:00',+        'd': '2026-07-09',+        't': '12:00:00',+        'td': 5400.0,+        'any_value': ['2026-07-09T12:00:00', 5400.0],+    }+    assert m.model_dump_json() == (+        '{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0,'+        '"any_value":["2026-07-09T12:00:00",5400.0]}'+    )++ def test_invalid_model():     class Foo:         pass 
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`.     ///     """