Backtestspydanticrun-20261009-110034#13664
JSON Schema ignores ser_json_temporal, so serialization schemas contradict model_dump_json() output
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the four schema methods the same way. `date_schema`, `time_schema` and `datetime_schema` now return `{'type': 'number'}` for 'seconds' or 'milliseconds'. `timedelta_schema` checks whether `ser_json_temporal` is present in `config_dict` before falling back to `ser_json_timedelta`, which matches pydantic-core and fixes both directions of the mismatch in the issue. B's shared `_common_temporal_schema` helper is a little tidier. A's inline checks are also clear. On this core logic they are equal.
The difference is default values. A also passes `temporal_mode=config.ser_json_temporal` to `to_jsonable_python` when encoding defaults. Without that, B produces `{'type': 'number', 'default': '2020-01-01T00:00:00'}` for a datetime field with a default under `ser_json_temporal='seconds'`. That schema contradicts itself in exactly the way the issue complains about: the published schema disagrees with what pydantic emits. A's `test_ser_json_temporal_defaults` covers this case (default 1577836800.0 and 300.0).
One risk with A: it now always passes `temporal_mode`. If pydantic-core let an explicitly passed default 'iso8601' override `timedelta_mode='float'`, the existing default-timedelta tests could regress. The test evidence reports no failures, so I treat this as a small residual risk.
On tests, both cover numeric versus iso8601 for all four types and timedelta precedence in both directions. A's tests also check the actual `model_dump_json` output alongside the schema for the precedence cases, plus defaults and TypedDict config. B's tests are broader on the type × mode grid but don't cover defaults.
A fixes more of the root mismatch and tests it, so A wins.
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
8m 28s
Wall-clock time in the container
Full test suite
No new failures
1,226 passed · 15 skipped · 1,241 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
107vs 88 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial 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
pydantic/json_schema.pyindex c2183e19..09305610 100644@@ -827,6 +827,8 @@ class GenerateJsonSchema: Returns: The generated JSON schema. """+ if 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._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._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,12 @@ 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.+ numeric = self._config.ser_json_temporal != 'iso8601'+ else:+ numeric = self._config.ser_json_timedelta == 'float'+ if numeric: return {'type': 'number'} return {'type': 'string', 'format': 'duration'} @@ -2452,7 +2463,11 @@ class GenerateJsonSchema: raise pydantic_core.PydanticSerializationError(f'Unable to encode default value {dft}') 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=config.ser_json_timedelta,+ 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..ae3fc66e 100644@@ -1960,6 +1960,94 @@ def test_typeddict_default_timedelta(ser_json_timedelta: Literal['float', 'iso86 } +@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())++ 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'},+ }+++def test_ser_json_temporal_iso8601():+ class Model(BaseModel):+ model_config = ConfigDict(ser_json_temporal='iso8601')++ dt: datetime+ d: date+ t: time+ td: timedelta++ 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'},+ }+++@pytest.mark.parametrize(+ 'ser_json_temporal,ser_json_timedelta,expected_schema,expected_dump',+ [+ ('iso8601', 'float', {'format': 'duration', 'title': 'Td', 'type': 'string'}, 'P1D'),+ ('seconds', 'iso8601', {'title': 'Td', 'type': 'number'}, 86400.0),+ ('milliseconds', 'iso8601', {'title': 'Td', 'type': 'number'}, 86400000.0),+ ],+)+def test_ser_json_temporal_takes_precedence_over_ser_json_timedelta(+ ser_json_temporal: Literal['iso8601', 'seconds', 'milliseconds'],+ ser_json_timedelta: Literal['iso8601', 'float'],+ expected_schema: dict[str, Any],+ expected_dump: Any,+):+ class Model(BaseModel):+ model_config = ConfigDict(ser_json_temporal=ser_json_temporal, ser_json_timedelta=ser_json_timedelta)++ td: timedelta++ assert json.loads(Model(td=timedelta(days=1)).model_dump_json()) == {'td': expected_dump}+ assert Model.model_json_schema(mode='serialization')['properties'] == {'td': expected_schema}+++def test_ser_json_temporal_defaults():+ class Model(BaseModel):+ model_config = ConfigDict(ser_json_temporal='seconds')++ dt: datetime = datetime(2020, 1, 1)+ td: timedelta = timedelta(minutes=5)++ assert Model.model_json_schema(mode='serialization')['properties'] == {+ 'dt': {'default': 1577836800.0, 'title': 'Dt', 'type': 'number'},+ 'td': {'default': 300.0, 'title': 'Td', 'type': 'number'},+ }+++def test_ser_json_temporal_typeddict():+ class MyTypedDict(TypedDict):+ __pydantic_config__ = ConfigDict(ser_json_temporal='milliseconds', ser_json_timedelta='iso8601')++ d: date+ td: timedelta++ assert TypeAdapter(MyTypedDict).json_schema(mode='serialization')['properties'] == {+ 'd': {'title': 'D', 'type': 'number'},+ 'td': {'title': 'Td', 'type': 'number'},+ }++ @pytest.mark.parametrize( 'ser_json_bytes,properties', [
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', [