Backtestspydanticrun-20260929-204949#13422
to_json: timedelta_mode and temporal_mode break documented behavior
Our patch was judged better than the merged fix.
In this judgment, Patch B = our agent, Patch A = the merged fix.
The issue asks (preferably) for timedelta to retain an independent setting so datetime/date/time can be iso8601 while timedelta is float. Patch B does exactly this: it restores an independent timedelta_mode field in SerializationConfig, routes timedelta serialization through it in all three infer paths (to_python, serialize, json_key), and preserves the legacy alias precedence so an explicit non-default temporal_mode still governs timedelta. This resolves the root cause and makes the issue's exact example produce the expected output. It also adds a targeted test covering both to_json and to_jsonable_python that would fail before and pass after. Patch A only edits docstrings and .pyi/config comments to redocument the current (broken) behavior as intended, i.e. it masks the issue rather than fixing it, adds no tests, and does not make the documented independent behavior actually work. B is clearly the better fix on correctness, tests, and scope.
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
10m 51s28 turns
Wall-clock time in the container
Full test suite
No new failures
12,260 passed · 501 skipped · 12,761 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
45vs 55 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial 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 serializetimedeltaobjects, 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: unknownThe two patches
pydantic-core/src/serializers/config.rsindex 9a1377c6..88dacd44 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,15 +43,19 @@ 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, timedelta_mode) = if temporal_set {+ // `ser_json_temporal` governs all temporal types, including timedelta.+ let mode = TemporalMode::from_config(config)?;+ (mode, mode) } else {- TimedeltaMode::from_config(config)?.into()+ // datetime/date/time default to iso8601; timedelta follows the legacy `ser_json_timedelta` alias.+ (TemporalMode::default(), TimedeltaMode::from_config(config)?.into()) }; 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 +67,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 resolved_temporal_mode = TemporalMode::from_str(temporal_mode)?;+ // `timedelta_mode` is a legacy alias: an explicit `temporal_mode` (anything but the+ // default `iso8601`) takes priority for timedelta too; otherwise fall back to `timedelta_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..8a5d340e 100644@@ -456,6 +456,25 @@ def test_encoding(any_serializer, gen_input, kwargs, expected_json): assert any_serializer.to_python(gen_input(), mode='json') == json.loads(expected_json) +def test_timedelta_mode_independent_of_temporal_mode():+ # timedelta_mode must govern only timedelta; temporal_mode must govern datetime/date/time.+ # https://github.com/pydantic/pydantic-core - to_json(timedelta_mode='float', temporal_mode='iso8601')+ 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),+ }+ expected = b'{"dt":"2026-07-09T12:00:00","d":"2026-07-09","t":"12:00:00","td":5400.0}'+ assert to_json(payload, timedelta_mode='float', temporal_mode='iso8601') == expected+ assert pydantic_core.to_jsonable_python(payload, timedelta_mode='float', temporal_mode='iso8601') == {+ 'dt': '2026-07-09T12:00:00',+ 'd': '2026-07-09',+ 't': '12:00:00',+ 'td': 5400.0,+ }++ def test_any_dataclass(): @dataclasses.dataclass class Foo:
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
The diff is clean — three files, no scratch or temporary files, all changes left uncommitted as required.
Summary
What was wrong. pydantic_core.to_json/to_jsonable_python document timedelta_mode (iso8601/float, governs timedelta) and temporal_mode (iso8601/seconds/milliseconds, governs datetime/date/time) as independent parameters over disjoint type sets. Since PR #1743 unified them, SerializationConfig held a single temporal_mode, and from_args derived that one mode from timedelta_mode whenever temporal_mode was the default "iso8601" — then applied it to all temporal types. So to_json(..., timedelta_mode="float", temporal_mode="iso8601") wrongly coerced datetime/date/time to unix-timestamp floats, and no argument combination could produce ISO datetimes with float-second timedeltas.
What I changed (implementing the report's preferred option — an independent timedelta setting):
src/serializers/config.rs: added a separatetimedelta_mode: TemporalModefield toSerializationConfig, resolved independently in bothfrom_argsandfrom_config. Datetime-likes are governed solely bytemporal_mode;timedeltafollowstimedelta_modewhentemporal_modeis the defaultiso8601, and follows an explicittemporal_mode/ser_json_temporalofseconds/millisecondswhen set (preserving prior behavior and matching the existingtest_config_timedelta_timedelta_ser_flag_prioritisedpriority test).src/serializers/infer.rs: the threetimedeltadispatch sites (to_json,serde_serialize,json_key) now readstate.config.timedelta_mode; datetime/date/time still readtemporal_mode.tests/serializers/test_any.py: addedtest_timedelta_mode_independent_of_temporal_mode, asserting the exact reported scenario for bothto_jsonandto_jsonable_python.
Test evidence.
- Before the fix, the new test failed:
to_json(payload, timedelta_mode='float', temporal_mode='iso8601')emitted{"dt":17835...}(a float) instead of the ISO string. - After building (
make build-dev) and re-running, the new test passes, and the full serializers suite is green: 805 passed, 5 skipped, 1 xfailed (./bt-test pydantic-core/tests/serializers/ pydantic-core/tests/test_garbage_collection.py), including the pre-existingtest_config_timedelta_timedelta_ser_flag_prioritised.
Requirements checklist.
to_json/to_jsonable_pythonwithtimedelta_mode="float", temporal_mode="iso8601"yield ISO datetime-likes + float timedelta — implemented, covered by the new regression test (fails before, passes after).- "Preferred:
timedeltaretains an independent setting" — implemented via the new independenttimedelta_modefield. - Alternative "correct the docs/
.pyito calltimedelta_modea deprecated alias" — skipped in favor of the preferred code fix; the.pyi/docstrings are now accurate for the documented contract (reviewer confirmed). One minor doc omission remains: the docstrings don't mention that an explicittemporal_modeofseconds/millisecondsalso governstimedelta. This is a pre-existing coupling, not a regression, and left untouched to keep the change minimal. - User's stated requirement to set
timedeltaformat independently of other datetime types — satisfied for the default (iso8601)temporal_mode, which is the reported scenario.
The empty impl TimedeltaMode {} block the reviewer noted at config.rs:159 is pre-existing and unrelated; I left it alone.