Backtestspydanticrun-20261003-150343#13664

Issue #13664 Merged fix PR #13665 Run 3 Oct 2026 · run-20261003-150343 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 core issue. In serialization mode, datetime/date/time/timedelta become `{'type': 'number'}` when `ser_json_temporal` is 'seconds' or 'milliseconds'. Both also mirror pydantic-core by checking whether `ser_json_temporal` is in the config dict before falling back to `ser_json_timedelta`.

Patch A ignores `self.mode`, which causes a regression. A model with `ser_json_temporal='seconds'` would now get `{'type': 'number'}` for date/time/datetime in the *validation* schema. ISO 8601 strings are valid input, so that schema now wrongly rejects them. `ser_json_temporal` is a serialization setting and should not change the validation schema of fields it never touched before.

Patch B gates the new number output on `mode == 'serialization'` and keeps the legacy `ser_json_timedelta='float'` behaviour unchanged for backward compatibility. It also fixes a closely related inconsistency that A leaves behind: default values in the schema. With A, a model with `ser_json_temporal='seconds'` and a datetime default would emit `type: number` alongside an ISO-string `default`. The precedence case (temporal='iso8601', timedelta='float') would likewise emit a float default under `type: string`, so the schema would still contradict itself. B passes `temporal_mode` and the correctly resolved `timedelta_mode` to `to_jsonable_python`. Defaults then match both the schema type and `model_dump_json()` output.

On tests, B is stronger. It asserts full schemas in both modes, checks that the validation schema is unchanged, and covers precedence together with defaults, plus dataclass defaults. A's tests are reasonable but only cover serialization-mode properties without defaults, so they would not catch the validation-mode regression or the default mismatch.

A's `_common_temporal_schema` helper is tidier, but correctness and test coverage favour B.

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 57s

Wall-clock time in the container

Full test suite

No new failures

12,355 passed · 500 skipped · 12,855 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

161vs 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+159 −2
pydantic/json_schema.pyindex c2183e19..a237c6a5 100644@@ -827,6 +827,8 @@ class GenerateJsonSchema:         Returns:             The generated JSON schema.         """+        if self.mode == 'serialization' and self._config.ser_json_temporal != 'iso8601':+            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.mode == 'serialization' and self._config.ser_json_temporal != 'iso8601':+            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.mode == 'serialization' and self._config.ser_json_temporal != 'iso8601':+            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':+        if 'ser_json_temporal' in self._config.config_dict:+            # Mirror pydantic-core: `ser_json_temporal` takes precedence over `ser_json_timedelta` when set.+            if self.mode == 'serialization' and self._config.ser_json_temporal != 'iso8601':+                return {'type': 'number'}+        elif self._config.ser_json_timedelta == 'float':             return {'type': 'number'}         return {'type': 'string', 'format': 'duration'} @@ -2451,8 +2461,14 @@ class GenerateJsonSchema:         except PydanticSchemaGenerationError:             raise pydantic_core.PydanticSerializationError(f'Unable to encode default value {dft}') +        # Mirror pydantic-core: `ser_json_temporal` takes precedence over `ser_json_timedelta` when set.+        timedelta_mode = 'iso8601' if 'ser_json_temporal' in config.config_dict else config.ser_json_timedelta         return pydantic_core.to_jsonable_python(-            default, timedelta_mode=config.ser_json_timedelta, bytes_mode=config.ser_json_bytes, by_alias=self.by_alias+            default,+            timedelta_mode=timedelta_mode,+            temporal_mode=config.ser_json_temporal,+            bytes_mode=config.ser_json_bytes,+            by_alias=self.by_alias,         )      def update_with_validations(tests/test_json_schema.pyindex 9cca3292..5fb54f2e 100644@@ -1981,6 +1981,147 @@ def test_typeddict_default_bytes(ser_json_bytes: Literal['base64', 'utf8'], prop     }  +@pytest.mark.parametrize('ser_json_temporal', ['seconds', 'milliseconds'])+def test_ser_json_temporal_numeric(ser_json_temporal: Literal['seconds', 'milliseconds']):+    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal=ser_json_temporal)++        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))+    dumped = json.loads(m.model_dump_json())+    assert all(isinstance(v, float) for v in dumped.values())++    # insert_assert(Model.model_json_schema(mode='serialization'))+    assert Model.model_json_schema(mode='serialization') == {+        'properties': {+            'dt': {'title': 'Dt', 'type': 'number'},+            'd': {'title': 'D', 'type': 'number'},+            't': {'title': 'T', 'type': 'number'},+            'td': {'title': 'Td', 'type': 'number'},+        },+        'required': ['dt', 'd', 't', 'td'],+        'title': 'Model',+        'type': 'object',+    }++    # `ser_json_temporal` only affects serialization, so the validation schema is unchanged:+    assert Model.model_json_schema(mode='validation') == {+        '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'},+        },+        'required': ['dt', 'd', 't', 'td'],+        'title': 'Model',+        'type': 'object',+    }+++def test_ser_json_temporal_iso8601():+    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal='iso8601')++        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 all(isinstance(v, str) for v in json.loads(m.model_dump_json()).values())++    # insert_assert(Model.model_json_schema(mode='serialization'))+    assert Model.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'},+        },+        'required': ['dt', 'd', 't', 'td'],+        'title': 'Model',+        'type': 'object',+    }+++@pytest.mark.parametrize(+    'ser_json_temporal,ser_json_timedelta,expected_dump,properties',+    [+        (+            'iso8601',+            'float',+            'PT5M',+            {'td': {'default': 'PT5M', 'format': 'duration', 'title': 'Td', 'type': 'string'}},+        ),+        ('seconds', 'iso8601', 300.0, {'td': {'default': 300.0, 'title': 'Td', 'type': 'number'}}),+        ('milliseconds', 'iso8601', 300000.0, {'td': {'default': 300000.0, 'title': 'Td', 'type': 'number'}}),+    ],+)+def test_ser_json_temporal_takes_precedence_over_ser_json_timedelta(+    ser_json_temporal: Literal['iso8601', 'seconds', 'milliseconds'],+    ser_json_timedelta: Literal['float', 'iso8601'],+    expected_dump: Any,+    properties: dict[str, Any],+):+    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal=ser_json_temporal, ser_json_timedelta=ser_json_timedelta)++        td: timedelta = timedelta(minutes=5)++    assert json.loads(Model().model_dump_json()) == {'td': expected_dump}++    # insert_assert(Model.model_json_schema(mode='serialization'))+    assert Model.model_json_schema(mode='serialization') == {+        'properties': properties,+        'title': 'Model',+        'type': 'object',+    }+++def test_ser_json_temporal_precedence_validation_mode():+    class Model(BaseModel):+        model_config = ConfigDict(ser_json_temporal='iso8601', ser_json_timedelta='float')++        td: timedelta = timedelta(minutes=5)++    assert json.loads(Model().model_dump_json()) == {'td': 'PT5M'}++    # The validation schema's type must agree with its default, which is serialized as an ISO 8601 duration:+    # insert_assert(Model.model_json_schema(mode='validation'))+    assert Model.model_json_schema(mode='validation') == {+        'properties': {'td': {'default': 'PT5M', 'format': 'duration', 'title': 'Td', 'type': 'string'}},+        'title': 'Model',+        'type': 'object',+    }+++@pytest.mark.parametrize(+    'ser_json_temporal,expected',+    [('seconds', 1577836800.0), ('milliseconds', 1577836800000.0)],+)+def test_ser_json_temporal_defaults(ser_json_temporal: Literal['seconds', 'milliseconds'], expected: float):+    @dataclass(config=ConfigDict(ser_json_temporal=ser_json_temporal))+    class Dataclass:+        dt: datetime = datetime(2020, 1, 1)+        d: date = date(2020, 1, 1)++    assert json.loads(TypeAdapter(Dataclass).dump_json(Dataclass())) == {'dt': expected, 'd': expected}++    # insert_assert(TypeAdapter(Dataclass).json_schema(mode='serialization'))+    assert TypeAdapter(Dataclass).json_schema(mode='serialization') == {+        'properties': {+            'dt': {'default': expected, 'title': 'Dt', 'type': 'number'},+            'd': {'default': expected, 'title': 'D', 'type': 'number'},+        },+        'title': 'Dataclass',+        'type': 'object',+    }++ def test_model_subclass_metadata():     class A(BaseModel):         """A Model docstring""" 
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',     [