Backtestspydanticrun-20260930-183947#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 root cause the same way. The date, time and datetime schemas now return `{'type': 'number'}` when `ser_json_temporal` is 'seconds' or 'milliseconds'. `timedelta_schema` mirrors pydantic-core's precedence: `ser_json_temporal` wins when it is present in the config, and otherwise the schema falls back to `ser_json_timedelta`. Patch A tests presence with `config_dict.get(...) is not None`, while B uses `'ser_json_temporal' in config_dict`. Since ConfigDict does not allow None for this key, the two behave the same in practice. On correctness, both resolve both scenarios in the issue.
On craft, Patch B is slightly cleaner. Its `_common_temporal_schema` helper removes the repeated tuple checks, and it maps `ser_json_timedelta` onto the temporal vocabulary. Patch A's inline checks are also clear and match the existing method style.
The difference is in the tests. Both would fail before the fix and pass after it. Both cover each temporal type under numeric settings and the timedelta precedence cases, including the reverse case from the issue. Patch A goes further in several ways:
- It checks that the schema type matches the actual `model_dump_json` output in the precedence tests.
- It checks that `ser_json_timedelta='float'` does not leak into datetime.
- It checks that the config applies through pydantic dataclasses and TypedDict `__pydantic_config__`.
- It checks that a nested model's schema uses its own config rather than the outer model's.
That nested-model test guards a real way a fix like this could go wrong. Patch B's tests are well structured and cover the type × format matrix, including iso8601, but they do not cover config scoping. With correctness equal and B's structural edge minor, Patch A's broader and more meaningful test coverage makes it the slightly better submission.
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
7m 29s
Wall-clock time in the container
Full test suite
No new failures
12,359 passed · 500 skipped · 12,859 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
133vs 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..9cfd1cf1 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,13 @@ 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`+ # whenever it is explicitly set in the config.+ if self._config.config_dict.get('ser_json_temporal') is not None:+ is_numeric = self._config.ser_json_temporal in ('seconds', 'milliseconds')+ else:+ is_numeric = self._config.ser_json_timedelta == 'float'+ if is_numeric: return {'type': 'number'} return {'type': 'string', 'format': 'duration'} tests/test_json_schema.pyindex 9cca3292..02ea8279 100644@@ -1981,6 +1981,125 @@ def test_typeddict_default_bytes(ser_json_bytes: Literal['base64', 'utf8'], prop } +def _json_type(value: Any) -> str:+ return 'number' if isinstance(value, (int, float)) else 'string'+++@pytest.mark.parametrize('ser_json_temporal', ['seconds', 'milliseconds'])+@pytest.mark.parametrize('mode', ['validation', 'serialization'])+def test_model_ser_json_temporal_numeric(+ ser_json_temporal: Literal['seconds', 'milliseconds'], mode: Literal['validation', 'serialization']+):+ class Model(BaseModel):+ model_config = ConfigDict(ser_json_temporal=ser_json_temporal)++ dt: datetime+ d: date+ t: time+ td: timedelta++ properties = Model.model_json_schema(mode=mode)['properties']+ assert properties == {+ 'dt': {'title': 'Dt', 'type': 'number'},+ 'd': {'title': 'D', 'type': 'number'},+ 't': {'title': 'T', 'type': 'number'},+ 'td': {'title': 'Td', 'type': 'number'},+ }++ dumped = json.loads(+ Model(dt=datetime(2020, 1, 1), d=date(2020, 1, 1), t=time(12, 0), td=timedelta(days=1)).model_dump_json()+ )+ assert {k: _json_type(v) for k, v in dumped.items()} == {k: v['type'] for k, v in properties.items()}+++def test_model_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(+ 'config,expected',+ [+ (+ ConfigDict(ser_json_temporal='iso8601', ser_json_timedelta='float'),+ {'format': 'duration', 'title': 'Td', 'type': 'string'},+ ),+ (ConfigDict(ser_json_temporal='seconds', ser_json_timedelta='iso8601'), {'title': 'Td', 'type': 'number'}),+ (ConfigDict(ser_json_timedelta='float'), {'title': 'Td', 'type': 'number'}),+ ],+)+def test_model_ser_json_temporal_takes_precedence_over_timedelta(config: ConfigDict, expected: dict[str, Any]):+ class Model(BaseModel):+ model_config = config++ td: timedelta++ properties = Model.model_json_schema(mode='serialization')['properties']+ assert properties == {'td': expected}+ dumped = json.loads(Model(td=timedelta(days=1)).model_dump_json())+ assert _json_type(dumped['td']) == expected['type']+++def test_ser_json_temporal_does_not_affect_timedelta_float_for_other_temporal_types():+ class Model(BaseModel):+ model_config = ConfigDict(ser_json_timedelta='float')++ dt: datetime++ assert Model.model_json_schema(mode='serialization')['properties'] == {+ 'dt': {'format': 'date-time', 'title': 'Dt', 'type': 'string'}+ }+ assert json.loads(Model(dt=datetime(2020, 1, 1)).model_dump_json()) == {'dt': '2020-01-01T00:00:00'}+++@pytest.mark.parametrize('ser_json_temporal', ['seconds', 'milliseconds'])+def test_ser_json_temporal_dataclass_and_typeddict(ser_json_temporal: Literal['seconds', 'milliseconds']):+ @pydantic.dataclasses.dataclass(config=ConfigDict(ser_json_temporal=ser_json_temporal))+ class MyDataclass:+ dt: datetime++ class MyTypedDict(TypedDict):+ __pydantic_config__ = ConfigDict(ser_json_temporal=ser_json_temporal)++ dt: datetime++ for tp in (MyDataclass, MyTypedDict):+ assert TypeAdapter(tp).json_schema(mode='serialization')['properties'] == {+ 'dt': {'title': 'Dt', 'type': 'number'}+ }++ dumped = json.loads(TypeAdapter(MyDataclass).dump_json(MyDataclass(dt=datetime(2020, 1, 1))))+ assert _json_type(dumped['dt']) == 'number'+++@pytest.mark.parametrize('ser_json_temporal', ['seconds', 'milliseconds'])+def test_ser_json_temporal_nested_model_uses_own_config(ser_json_temporal: Literal['seconds', 'milliseconds']):+ class Inner(BaseModel):+ model_config = ConfigDict(ser_json_temporal=ser_json_temporal)++ dt: datetime++ class Outer(BaseModel):+ inner: Inner+ dt: datetime++ schema = Outer.model_json_schema(mode='serialization')+ assert schema['$defs']['Inner']['properties'] == {'dt': {'title': 'Dt', 'type': 'number'}}+ assert schema['properties']['dt'] == {'format': 'date-time', 'title': 'Dt', 'type': 'string'}++ def test_model_subclass_metadata(): class A(BaseModel): """A Model docstring"""
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', [