Backtestspydanticrun-20261002-175417#13664

Issue #13664 Merged fix PR #13665 Run 2 Oct 2026 · run-20261002-175417 pydantic/pydantic

JSON Schema ignores ser_json_temporal, so serialization schemas contradict model_dump_json() output

Better

Our patch was judged better than the merged fix.

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

Both patches fix the root cause the same way. They make `date_schema`, `time_schema` and `datetime_schema` return `{'type': 'number'}` when `ser_json_temporal` is 'seconds' or 'milliseconds'. In `timedelta_schema` they follow pydantic-core's precedence: if `'ser_json_temporal' in config_dict` they use that setting, otherwise they fall back to `ser_json_timedelta`. For valid config values the two give identical results, including both precedence directions the issue describes.

Patch A moves the logic into a `_common_temporal_schema` helper. That removes some duplication, but it has small costs. The helper treats any non-'iso8601' value as a number, which is less explicit than B's whitelist of 'seconds' and 'milliseconds'. Its parameter is named `format`, which shadows a builtin. It also adds a private method between the public schema methods. Patch B's inline checks are a little repetitive, but each one is obvious and has a comment explaining the precedence.

Tests decide it. Patch A's tests check the generated schema for each type and mode, plus the precedence table. Its 'matches serialized output' test only checks the coarse `type` and whether the dumped value is a str or float.

Patch B's tests check the exact `model_dump_json()` output and the exact schema properties together. They cover all three modes, both precedence directions, and `ser_json_timedelta` alone leaving the other temporal types untouched. They also cover schema defaults under `ser_json_temporal` and config arriving through dataclasses and TypedDicts. Both test suites would fail before the fix, but B's tie the schema to the real serializer output more tightly and cover more config paths.

Correctness is equal, and B has the stronger tests with clear code, so B is the better patch.

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

11m 45s

Wall-clock time in the container

Full test suite

No new failures

12,358 passed · 500 skipped · 12,858 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

124vs 88 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

ser_json_temporal landed in v2.12 and controls how datetime, date, time and timedelta are serialized to JSON. GenerateJsonSchema was never told about it, so a mode='serialization' schema still says these fields are strings even when model_dump_json() writes numbers.

With ser_json_temporal='seconds' (same with 'milliseconds'), every temporal field is affected:

schema:  {'dt': {'type': 'string', 'format': 'date-time'}, 'td': {'type': 'string', 'format': 'duration'}}
dump:    {'dt': 1577836800.0, 'td': 86400.0}

Running that payload through a JSON Schema validator fails with 1577836800.0 is not of type 'string', so the schema pydantic publishes rejects the output pydantic itself just produced. date_schema, time_schema and datetime_schema read no config at all right now.

There is a second mismatch that goes the other way, on timedelta. timedelta_schema only looks at the older ser_json_timedelta setting. The docs for ser_json_temporal say it takes precedence over ser_json_timedelta, and pydantic-core implements exactly that: SerializationConfig::from_config and TimeDeltaSerializer::build both check whether ser_json_temporal is present in the config before falling back to ser_json_timedelta. The JSON schema layer does not, so setting ser_json_temporal='iso8601' together with ser_json_timedelta='float' gives you the reverse problem:

schema:  {'td': {'type': 'number'}}
dump:    {'td': 'P1D'}

For anyone generating an OpenAPI document from a model this is a silent wrong answer rather than a crash, which is probably why it has gone unnoticed since the setting was added.

I have a patch that mirrors the pydantic-core resolution in the four temporal schema methods, plus tests. Happy to open a PR if you want to assign this to me.

Example Code

import json
from datetime import date, datetime, time, timedelta

from pydantic import BaseModel, ConfigDict


class Numeric(BaseModel):
    model_config = ConfigDict(ser_json_temporal='seconds')

    dt: datetime
    d: date
    t: time
    td: timedelta


model = Numeric(dt=datetime(2020, 1, 1), d=date(2020, 1, 1), t=time(12, 0), td=timedelta(days=1))

print(Numeric.model_json_schema(mode='serialization')['properties'])
#> {'dt': {'format': 'date-time', 'title': 'Dt', 'type': 'string'},
#>  'd': {'format': 'date', 'title': 'D', 'type': 'string'},
#>  't': {'format': 'time', 'title': 'T', 'type': 'string'},
#>  'td': {'format': 'duration', 'title': 'Td', 'type': 'string'}}

print(json.loads(model.model_dump_json()))
#> {'dt': 1577836800.0, 'd': 1577836800.0, 't': 43200.0, 'td': 86400.0}


# The timedelta precedence case, wrong in the opposite direction:
class Precedence(BaseModel):
    model_config = ConfigDict(ser_json_temporal='iso8601', ser_json_timedelta='float')

    td: timedelta


print(Precedence.model_json_schema(mode='serialization')['properties'])
#> {'td': {'title': 'Td', 'type': 'number'}}

print(json.loads(Precedence(td=timedelta(days=1)).model_dump_json()))
#> {'td': 'P1D'}

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.12.13 (main, May 10 2026, 19:20:41) [Clang 22.1.3 ]
                     platform: macOS-15.7.4-arm64-arm-64bit
             related packages: typing_extensions-4.16.0
                       commit: unknown

Also reproduces on main (2.14.0b1 / pydantic-core 2.48.0).

The two patches

Our patch+123 −1
pydantic/json_schema.pyindex c2183e19..b5239620 100644@@ -827,6 +827,8 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """+        if self._config.ser_json_temporal in ('seconds', 'milliseconds'):+            return {'type': 'number'}         return {'type': 'string', 'format': 'date'}      def time_schema(self, schema: core_schema.TimeSchema) -> JsonSchemaValue:@@ -838,6 +840,8 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """+        if self._config.ser_json_temporal in ('seconds', 'milliseconds'):+            return {'type': 'number'}         return {'type': 'string', 'format': 'time'}      def datetime_schema(self, schema: core_schema.DatetimeSchema) -> JsonSchemaValue:@@ -849,6 +853,8 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """+        if self._config.ser_json_temporal in ('seconds', 'milliseconds'):+            return {'type': 'number'}         return {'type': 'string', 'format': 'date-time'}      def timedelta_schema(self, schema: core_schema.TimedeltaSchema) -> JsonSchemaValue:@@ -860,7 +866,11 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """-        if self._config.ser_json_timedelta == 'float':+        # Mirror pydantic-core: `ser_json_temporal` takes precedence over `ser_json_timedelta` when it is set:+        if 'ser_json_temporal' in self._config.config_dict:+            if self._config.ser_json_temporal in ('seconds', 'milliseconds'):+                return {'type': 'number'}+        elif self._config.ser_json_timedelta == 'float':             return {'type': 'number'}         return {'type': 'string', 'format': 'duration'} tests/test_json_schema.pyindex 9cca3292..e1206e4b 100644@@ -1878,6 +1878,118 @@ def test_model_default_timedelta(ser_json_timedelta: Literal['float', 'iso8601']     }  +_TEMPORAL_STRING_PROPERTIES = {+    'dt': {'format': 'date-time', 'title': 'Dt', 'type': 'string'},+    'd': {'format': 'date', 'title': 'D', 'type': 'string'},+    't': {'format': 'time', 'title': 'T', 'type': 'string'},+    'td': {'format': 'duration', 'title': 'Td', 'type': 'string'},+}+_TEMPORAL_NUMBER_PROPERTIES = {+    'dt': {'title': 'Dt', 'type': 'number'},+    'd': {'title': 'D', 'type': 'number'},+    't': {'title': 'T', 'type': 'number'},+    'td': {'title': 'Td', 'type': 'number'},+}+++@pytest.mark.parametrize(+    'config,properties,dumped',+    [+        (+            ConfigDict(ser_json_temporal='iso8601'),+            _TEMPORAL_STRING_PROPERTIES,+            {'dt': '2020-01-01T00:00:00', 'd': '2020-01-01', 't': '12:00:00', 'td': 'P1D'},+        ),+        (+            ConfigDict(ser_json_temporal='seconds'),+            _TEMPORAL_NUMBER_PROPERTIES,+            {'dt': 1577836800.0, 'd': 1577836800.0, 't': 43200.0, 'td': 86400.0},+        ),+        (+            ConfigDict(ser_json_temporal='milliseconds'),+            _TEMPORAL_NUMBER_PROPERTIES,+            {'dt': 1577836800000.0, 'd': 1577836800000.0, 't': 43200000.0, 'td': 86400000.0},+        ),+        # `ser_json_temporal` takes precedence over `ser_json_timedelta`, in both directions:+        (+            ConfigDict(ser_json_temporal='iso8601', ser_json_timedelta='float'),+            _TEMPORAL_STRING_PROPERTIES,+            {'dt': '2020-01-01T00:00:00', 'd': '2020-01-01', 't': '12:00:00', 'td': 'P1D'},+        ),+        (+            ConfigDict(ser_json_temporal='seconds', ser_json_timedelta='iso8601'),+            _TEMPORAL_NUMBER_PROPERTIES,+            {'dt': 1577836800.0, 'd': 1577836800.0, 't': 43200.0, 'td': 86400.0},+        ),+        # `ser_json_timedelta` alone only affects timedeltas:+        (+            ConfigDict(ser_json_timedelta='float'),+            {**_TEMPORAL_STRING_PROPERTIES, 'td': {'title': 'Td', 'type': 'number'}},+            {'dt': '2020-01-01T00:00:00', 'd': '2020-01-01', 't': '12:00:00', 'td': 86400.0},+        ),+    ],+)+def test_ser_json_temporal(config: ConfigDict, properties: dict[str, Any], dumped: dict[str, Any]) -> None:+    class Model(BaseModel):+        model_config = config++        dt: datetime+        d: date+        t: time+        td: timedelta++    m = Model(dt=datetime(2020, 1, 1), d=date(2020, 1, 1), t=time(12, 0), td=timedelta(days=1))+    assert json.loads(m.model_dump_json()) == dumped+    assert Model.model_json_schema(mode='serialization')['properties'] == properties+++@pytest.mark.parametrize(+    'ser_json_temporal,properties',+    [+        ('seconds', {'duration': {'default': 300.0, 'title': 'Duration', 'type': 'number'}}),+        ('milliseconds', {'duration': {'default': 300000.0, 'title': 'Duration', 'type': 'number'}}),+        ('iso8601', {'duration': {'default': 'PT5M', 'format': 'duration', 'title': 'Duration', 'type': 'string'}}),+    ],+)+def test_model_default_timedelta_ser_json_temporal(+    ser_json_temporal: Literal['iso8601', 'seconds', 'milliseconds'], properties: dict[str, Any]+) -> None:+    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal=ser_json_temporal, ser_json_timedelta='iso8601')++        duration: timedelta = timedelta(minutes=5)++    assert Model.model_json_schema(mode='serialization') == {+        'properties': properties,+        'title': 'Model',+        'type': 'object',+    }+++@pytest.mark.parametrize(+    'ser_json_temporal,schema',+    [+        ('seconds', {'title': 'Dt', 'type': 'number'}),+        ('milliseconds', {'title': 'Dt', 'type': 'number'}),+        ('iso8601', {'title': 'Dt', 'type': 'string', 'format': 'date-time'}),+    ],+)+def test_dataclass_and_typeddict_ser_json_temporal(+    ser_json_temporal: Literal['iso8601', 'seconds', 'milliseconds'], schema: dict[str, Any]+) -> None:+    @dataclass(config=ConfigDict(ser_json_temporal=ser_json_temporal))+    class Dataclass:+        dt: datetime++    class MyTypedDict(TypedDict):+        __pydantic_config__ = ConfigDict(ser_json_temporal=ser_json_temporal)++        dt: datetime++    assert TypeAdapter(Dataclass).json_schema(mode='serialization')['properties'] == {'dt': schema}+    assert TypeAdapter(MyTypedDict).json_schema(mode='serialization')['properties'] == {'dt': schema}++ @pytest.mark.parametrize(     'ser_json_bytes,properties',     [ 
Merged fix · PR #13665+83 −5
pydantic/json_schema.pyindex c2183e193..aa330bc66 100644@@ -827,7 +827,7 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """-        return {'type': 'string', 'format': 'date'}+        return self._common_temporal_schema('date', self._config.ser_json_temporal)      def time_schema(self, schema: core_schema.TimeSchema) -> JsonSchemaValue:         """Generates a JSON schema that matches a time value.@@ -838,7 +838,7 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """-        return {'type': 'string', 'format': 'time'}+        return self._common_temporal_schema('time', self._config.ser_json_temporal)      def datetime_schema(self, schema: core_schema.DatetimeSchema) -> JsonSchemaValue:         """Generates a JSON schema that matches a datetime value.@@ -849,7 +849,7 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """-        return {'type': 'string', 'format': 'date-time'}+        return self._common_temporal_schema('date-time', self._config.ser_json_temporal)      def timedelta_schema(self, schema: core_schema.TimedeltaSchema) -> JsonSchemaValue:         """Generates a JSON schema that matches a timedelta value.@@ -860,9 +860,21 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """-        if self._config.ser_json_timedelta == 'float':+        if 'ser_json_temporal' in self._config.config_dict:+            temporal_format = self._config.ser_json_temporal+        else:+            # `ser_json_temporal` supersedes `ser_json_timedelta`, which only applies when the former isn't+            # explicitly set.+            temporal_format = 'seconds' if self._config.ser_json_timedelta == 'float' else 'iso8601'+        return self._common_temporal_schema('duration', temporal_format)++    def _common_temporal_schema(+        self, format: str, temporal_format: Literal['iso8601', 'seconds', 'milliseconds']+    ) -> JsonSchemaValue:+        if temporal_format != 'iso8601':+            # Both `'seconds'` and `'milliseconds'` serialize to a number:             return {'type': 'number'}-        return {'type': 'string', 'format': 'duration'}+        return {'type': 'string', 'format': format}      def literal_schema(self, schema: core_schema.LiteralSchema) -> JsonSchemaValue:         """Generates a JSON schema that matches a literal value.tests/test_json_schema.pyindex 9cca32928..5157bdb80 100644@@ -830,6 +830,72 @@ def test_date_types(field_type, expected_schema):     assert Model.model_json_schema() == base_schema  +@pytest.mark.parametrize('ser_json_temporal', ['iso8601', 'seconds', 'milliseconds'])+@pytest.mark.parametrize(+    'field_type,iso8601_format',+    [+        (datetime, 'date-time'),+        (date, 'date'),+        (time, 'time'),+        (timedelta, 'duration'),+    ],+)+def test_date_types_ser_json_temporal(field_type, iso8601_format, ser_json_temporal):+    """https://github.com/pydantic/pydantic/issues/13664"""++    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal=ser_json_temporal)++        a: field_type++    if ser_json_temporal == 'iso8601':+        expected_schema = {'title': 'A', 'type': 'string', 'format': iso8601_format}+    else:+        expected_schema = {'title': 'A', 'type': 'number'}++    assert Model.model_json_schema(mode='serialization')['properties']['a'] == expected_schema+++@pytest.mark.parametrize('ser_json_temporal', ['iso8601', 'seconds', 'milliseconds'])+def test_date_types_ser_json_temporal_matches_serialized_output(ser_json_temporal):+    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal=ser_json_temporal)++        dt: datetime+        d: date+        t: time+        td: timedelta++    model = Model(dt=datetime(2020, 1, 1), d=date(2020, 1, 1), t=time(12, 0), td=timedelta(days=1))+    properties = Model.model_json_schema(mode='serialization')['properties']+    expected_type = 'string' if ser_json_temporal == 'iso8601' else 'number'++    for field_name, value in json.loads(model.model_dump_json()).items():+        assert properties[field_name]['type'] == expected_type+        if ser_json_temporal == 'iso8601':+            assert isinstance(value, str)+        else:+            assert isinstance(value, float)+++@pytest.mark.parametrize(+    'config,expected_schema',+    [+        ({'ser_json_timedelta': 'float'}, {'type': 'number'}),+        ({'ser_json_timedelta': 'iso8601'}, {'type': 'string', 'format': 'duration'}),+        ({'ser_json_temporal': 'seconds', 'ser_json_timedelta': 'iso8601'}, {'type': 'number'}),+        ({'ser_json_temporal': 'iso8601', 'ser_json_timedelta': 'float'}, {'type': 'string', 'format': 'duration'}),+    ],+)+def test_timedelta_ser_json_temporal_takes_precedence(config, expected_schema):+    class Model(BaseModel):+        model_config = config++        a: timedelta++    assert Model.model_json_schema(mode='serialization')['properties']['a'] == {'title': 'A', **expected_schema}++ @pytest.mark.parametrize(     'interval',     [