Backtestspydanticrun-20261013-104308#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 B = our agent, Patch A = the merged fix.
Both patches fix the core schema bug the same way. `date_schema`, `time_schema` and `datetime_schema` now return `{'type': 'number'}` for 'seconds'/'milliseconds'. `timedelta_schema` mirrors pydantic-core's precedence by checking `'ser_json_temporal' in config_dict` before falling back to `ser_json_timedelta`. Both handle the issue's two scenarios: numeric temporal modes, and iso8601 temporal overriding float timedelta.
The difference is in default values. Patch A leaves `encode_default` calling `to_jsonable_python` with only `timedelta_mode`. With `ser_json_temporal='seconds'` and a datetime or timedelta default, A emits a schema that says `type: number` but carries an ISO-string `default`. That is internally contradictory and is the same 'schema disagrees with serialized output' problem the issue reports. Patch B passes `temporal_mode=config.ser_json_temporal` there too. Its parametrized dataclass and TypedDict tests confirm defaults become 1577836800.0 / 300.0 (and the millisecond equivalents).
One risk in B: I could not confirm from the diff alone how pydantic-core resolves `timedelta_mode` against an always-supplied `temporal_mode` when only `ser_json_timedelta='float'` is configured. If core does not apply the same precedence there, existing timedelta-default behavior could change. I judge this low risk because core explicitly supports both arguments, but it does limit my confidence somewhat.
On tests, both suites would fail before the fix and pass after. Each checks schema types against actual `model_dump_json` output and covers precedence. B goes further: it asserts the exact dumped values in the precedence cases, checks that a nested model with its own config gets the right schema in `$defs`, and covers defaults.
On craft, A's shared `_common_temporal_schema` helper is somewhat tidier than B's repeated inline checks, but that is minor.
Overall, B resolves the inconsistency more completely and has stronger tests.
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
6m 24s
Wall-clock time in the container
Full test suite
No new failures
1,227 passed · 15 skipped · 1,242 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
161vs 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..45fbb674 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':+ config = self._config+ # Mirror pydantic-core: `ser_json_temporal` takes precedence over `ser_json_timedelta` when explicitly set+ if 'ser_json_temporal' in config.config_dict:+ numeric = config.ser_json_temporal in ('seconds', 'milliseconds')+ else:+ numeric = config.ser_json_timedelta == 'float'+ if numeric: return {'type': 'number'} return {'type': 'string', 'format': 'duration'} @@ -2452,7 +2464,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..4a5c6fdb 100644@@ -1981,6 +1981,147 @@ def test_typeddict_default_bytes(ser_json_bytes: Literal['base64', 'utf8'], prop } +@pytest.mark.parametrize(+ 'ser_json_temporal,expected_properties',+ [+ (+ 'iso8601',+ {+ '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'},+ },+ ),+ (+ 'seconds',+ {+ 'dt': {'title': 'Dt', 'type': 'number'},+ 'd': {'title': 'D', 'type': 'number'},+ 't': {'title': 'T', 'type': 'number'},+ 'td': {'title': 'Td', 'type': 'number'},+ },+ ),+ (+ 'milliseconds',+ {+ '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_schema_matches_dump(+ ser_json_temporal: Literal['iso8601', 'seconds', 'milliseconds'], expected_properties: dict[str, Any]+) -> None:+ 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='serialization')['properties']+ assert properties == expected_properties++ 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()+ )+ json_types = {'string': str, 'number': (int, float)}+ for name, value in dumped.items():+ assert isinstance(value, json_types[properties[name]['type']]), name+++@pytest.mark.parametrize(+ 'config,expected_td_schema,expected_dump',+ [+ (+ ConfigDict(ser_json_temporal='iso8601', ser_json_timedelta='float'),+ {'format': 'duration', 'title': 'Td', 'type': 'string'},+ 'P1D',+ ),+ (+ ConfigDict(ser_json_temporal='seconds', ser_json_timedelta='iso8601'),+ {'title': 'Td', 'type': 'number'},+ 86400.0,+ ),+ (+ ConfigDict(ser_json_timedelta='float'),+ {'title': 'Td', 'type': 'number'},+ 86400.0,+ ),+ ],+)+def test_ser_json_temporal_takes_precedence_over_ser_json_timedelta(+ config: ConfigDict, expected_td_schema: dict[str, Any], expected_dump: Any+) -> None:+ class Model(BaseModel):+ model_config = config++ td: timedelta++ assert Model.model_json_schema(mode='serialization')['properties'] == {'td': expected_td_schema}+ assert json.loads(Model(td=timedelta(days=1)).model_dump_json()) == {'td': expected_dump}+++@pytest.mark.parametrize(+ 'ser_json_temporal,properties',+ [+ (+ 'seconds',+ {+ 'dt': {'default': 1577836800.0, 'title': 'Dt', 'type': 'number'},+ 'td': {'default': 300.0, 'title': 'Td', 'type': 'number'},+ },+ ),+ (+ 'milliseconds',+ {+ 'dt': {'default': 1577836800000.0, 'title': 'Dt', 'type': 'number'},+ 'td': {'default': 300000.0, 'title': 'Td', 'type': 'number'},+ },+ ),+ ],+)+def test_ser_json_temporal_defaults_dataclass_and_typeddict(+ ser_json_temporal: Literal['seconds', 'milliseconds'], properties: dict[str, Any]+) -> None:+ @dataclass(config=ConfigDict(ser_json_temporal=ser_json_temporal))+ class Dataclass:+ dt: datetime = datetime(2020, 1, 1)+ td: timedelta = timedelta(minutes=5)++ class MyTypedDict(TypedDict):+ __pydantic_config__ = ConfigDict(ser_json_temporal=ser_json_temporal)++ dt: Annotated[datetime, Field(datetime(2020, 1, 1))]+ td: Annotated[timedelta, Field(timedelta(minutes=5))]++ assert TypeAdapter(Dataclass).json_schema(mode='serialization')['properties'] == properties+ assert TypeAdapter(MyTypedDict).json_schema(mode='serialization')['properties'] == properties+++def test_ser_json_temporal_nested_model_uses_own_config() -> None:+ class Inner(BaseModel):+ model_config = ConfigDict(ser_json_temporal='seconds')++ dt: datetime++ class Outer(BaseModel):+ dt: datetime+ inner: Inner++ schema = Outer.model_json_schema(mode='serialization')+ assert schema['properties']['dt'] == {'format': 'date-time', 'title': 'Dt', 'type': 'string'}+ assert schema['$defs']['Inner']['properties']['dt'] == {'title': 'Dt', 'type': 'number'}++ dumped = json.loads(Outer(dt=datetime(2020, 1, 1), inner=Inner(dt=datetime(2020, 1, 1))).model_dump_json())+ assert dumped == {'dt': '2020-01-01T00:00:00', 'inner': {'dt': 1577836800.0}}++ 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', [