Backtestspydanticrun-20261022-024030#13017
Decimal JSON schema pattern uses lookahead regex unsupported by pydantic-core
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches make the emitted Decimal pattern compilable by pydantic-core, and the independent tests pass on both. Patch A fixes the root cause directly: it rewrites the four constraint cases without look-around, keeps the same anchored structure (`^[+-]?(?:...)$`), handles the decimal_places > max_digits edge via `min(decimal_places, max_digits)`, enumerates integer-width alternatives for the max_digits-only case, and preserves existing behaviour (leading/trailing zeros, rejection of '', '.', '+-'). Its new tests compile each pattern through `TypeAdapter(Annotated[str, StringConstraints(pattern=...)])` and check both valid and invalid strings for every constraint combination, plus a direct reproduction of the issue's model_json_schema round-trip. These would fail on base with SchemaError and pass after. Patch B resolves the issue mainly by removing the pattern from the default JSON schema entirely and moving pattern generation behind an opt-in `get_decimal_pattern` hook. That is a user-visible feature removal (max_digits/decimal_places no longer reflected in the schema by default, docs changed to 'N/A') that the issue did not ask for, and it means ordinary users still get no pydantic-core-compatible pattern unless they subclass the generator. Alongside that it adds a large redesign: separate validation/serialization patterns modelling `str(Decimal)` output including scientific notation thresholds, an `_int_range_pattern` helper, allow_inf_nan handling, and unrelated code movement of `_HashableJsonValue`. The extra machinery is extensively tested, but it is well beyond scope and the serialization-pattern logic (exponent ranges, E-7 cutoff, per-k enumeration) is intricate and high-risk relative to the ask. Existing pattern tests in B were rewritten to pass through a custom generator, so they no longer exercise default behaviour. Patch A is the focused, correct, well-tested fix; Patch B fixes the symptom by dropping the feature and bundles a risky redesign.
Four judges ruled on this ticket in parallel, and the verdict comes from counting their votes. Each saw the issue and the two patches, labelled A and B in random order (two of them saw ours as A), with issue links and version numbers removed. Where tests could check the fix, they also saw the results of tests a separate agent wrote for the issue, run on both patches. None was told which patch was ours. The reasoning above is one judge's, shown verbatim.
Solve
35m 35s
Wall-clock time in the container
Full test suite
No new failures
1,267 passed · 15 skipped · 1,282 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
139vs 573 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial Checks
- I confirm that I'm using Pydantic V2
Description
Pydantic v2 emits a JSON schema for Decimal fields that includes a regex pattern with a negative lookahead ((?!...)). This pattern cannot be compiled by pydantic-core's Rust regex crate, which does not support look-around assertions.
This means the JSON schema pydantic produces for Decimal cannot be round-tripped back through pydantic's own validation e.g. constructing a TypeAdapter with StringConstraints(pattern=...) using the emitted pattern fails with a SchemaError.
This is a practical problem for any tooling that reconstructs pydantic types from emitted JSON schemas (e.g. MCP structured content parsing via FastMCP).
Example Code
"""Minimal reproduction: Decimal JSON schema pattern uses lookahead unsupported by pydantic-core.
Pydantic generates a JSON schema for Decimal fields with a regex pattern that uses
a negative lookahead (?!...). When that schema is round-tripped back through pydantic
(e.g. via TypeAdapter with StringConstraints), pydantic-core's Rust regex engine
rejects it because it does not support look-around assertions.
"""
from decimal import Decimal
from typing import Annotated
from pydantic import BaseModel, StringConstraints, TypeAdapter
class MyModel(BaseModel):
amount: Decimal
def test_decimal_json_schema_pattern_roundtrips_through_pydantic_core():
schema = MyModel.model_json_schema()
# Decimal emits an anyOf with a string variant carrying the pattern
string_variant = next(v for v in schema['properties']['amount']['anyOf'] if v.get('type') == 'string')
pattern = string_variant['pattern']
# The emitted pattern contains a negative lookahead:
assert '(?!' in pattern
# Feeding it back into StringConstraints fails with:
# SchemaError: regex parse error: look-around ... is not supported
ConstrainedStr = Annotated[str, StringConstraints(pattern=pattern)]
TypeAdapter(ConstrainedStr)
if __name__ == '__main__':
test_decimal_json_schema_pattern_roundtrips_through_pydantic_core()
Python, Pydantic & OS Version
pydantic version: 2.11.10
pydantic-core version: 2.33.2
pydantic-core build: profile=release pgo=false
python version: 3.13.9 (main, Oct 14 2025, 13:52:31) [Clang 17.0.0 (clang-1700.3.19.1)]
platform: macOS-26.3.1-arm64-arm-64bit-Mach-O
related packages: pydantic-extra-types-2.11.0 pyright-1.1.408 email-validator-2.3.0 fastapi-0.135.1 typing_extensions-4.15.0 pydantic-settings-2.13.0
commit: unknownThe two patches
docs/concepts/json_schema.mdindex cd8bc01a..a69a3061 100644@@ -278,7 +278,7 @@ print(Model.model_json_schema(mode='validation')) 'anyOf': [ {'type': 'number'}, {- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', 'type': 'string', }, ],@@ -297,7 +297,7 @@ print(Model.model_json_schema(mode='serialization')) 'properties': { 'a': { 'default': '12.34',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', 'title': 'A', 'type': 'string', }pydantic/json_schema.pyindex 8135c60b..3b8ad405 100644@@ -725,45 +725,55 @@ class GenerateJsonSchema: """ def get_decimal_pattern(schema: core_schema.DecimalSchema) -> str:+ # Look-around assertions are deliberately avoided, as they are not supported by+ # many regex engines (including the Rust `regex` crate used by `pydantic-core`). max_digits = schema.get('max_digits') decimal_places = schema.get('decimal_places') - pattern = (- r'^(?!^[-+.]*$)[+-]?0*' # check it is not empty string and not one or sequence of ".+-" characters.- )+ def bounded_digits(n: int) -> str:+ # A non-empty sequence of at most `n` digits (or only zeros if `n` is 0). Zero padding+ # (leading zeros for the integer part, trailing zeros for the fractional part) is added by the caller.+ if n == 0:+ return '0+'+ return rf'\d{{1,{n}}}'++ def number_pattern(integer_places: int | None, fraction_places: int | None) -> str:+ integer_part = r'\d+' if integer_places is None else rf'0*{bounded_digits(integer_places)}'+ if fraction_places is None:+ fraction_part = r'\d+'+ elif fraction_places == 0:+ fraction_part = '0+'+ else:+ fraction_part = rf'{bounded_digits(fraction_places)}0*'+ optional_fraction_part = r'\d*' if fraction_places is None else rf'(?:{fraction_part})?'+ # Either an integer part (optionally followed by a dot and a fractional part),+ # or a dot followed by a non-empty fractional part.+ return rf'{integer_part}(?:\.{optional_fraction_part})?|\.{fraction_part}' # Case 1: Both max_digits and decimal_places are set if max_digits is not None and decimal_places is not None: integer_places = max(0, max_digits - decimal_places)- pattern += (- rf'(?:'- rf'\d{{0,{integer_places}}}'- rf'|'- rf'(?=[\d.]{{1,{max_digits + 1}}}0*$)'- rf'\d{{0,{integer_places}}}\.\d{{0,{decimal_places}}}0*$'- rf')'- )+ body = number_pattern(integer_places, min(decimal_places, max_digits)) # Case 2: Only max_digits is set elif max_digits is not None and decimal_places is None:- pattern += (- rf'(?:'- rf'\d{{0,{max_digits}}}'- rf'|'- rf'(?=[\d.]{{1,{max_digits + 1}}}0*$)'- rf'\d*\.\d*0*$'- rf')'- )+ # The integer and fractional parts share the `max_digits` budget, so enumerate+ # the possible number of integer digits:+ alternatives = [number_pattern(max_digits, 0)]+ for integer_places in range(max_digits):+ integer_part = rf'\d{{{integer_places}}}' if integer_places else ''+ alternatives.append(rf'0*{integer_part}\.{bounded_digits(max_digits - integer_places)}0*')+ body = '|'.join(alternatives) # Case 3: Only decimal_places is set elif max_digits is None and decimal_places is not None:- pattern += rf'\d*\.?\d{{0,{decimal_places}}}0*$'+ body = number_pattern(None, decimal_places) # Case 4: Both are None (no restrictions) else:- pattern += r'\d*\.?\d*$' # look for arbitrary integer or decimal+ body = number_pattern(None, None) - return pattern+ return rf'^[+-]?(?:{body})$' json_schema = self.str_schema(core_schema.str_schema(pattern=get_decimal_pattern(schema))) if self.mode == 'validation':tests/test_json_schema.pyindex b1907b72..1af29aeb 100644@@ -564,7 +564,7 @@ def test_decimal_json_schema(): {'type': 'number'}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ], 'default': '12.34',@@ -581,7 +581,7 @@ def test_decimal_json_schema(): 'default': '12.34', 'title': 'B', 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, }, 'title': 'Model',@@ -1172,7 +1172,7 @@ def test_special_decimal_types(field_type, expected_schema): {'type': 'number'}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ], 'title': 'A',@@ -2175,7 +2175,7 @@ def test_docstring(docstring, description): {'exclusiveMinimum': 2.0, 'type': 'number'}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ] },@@ -2188,7 +2188,7 @@ def test_docstring(docstring, description): {'type': 'number', 'exclusiveMaximum': 5}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ] },@@ -2201,7 +2201,7 @@ def test_docstring(docstring, description): {'type': 'number', 'minimum': 2}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ] },@@ -2214,7 +2214,7 @@ def test_docstring(docstring, description): {'type': 'number', 'maximum': 5}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ] },@@ -2227,7 +2227,7 @@ def test_docstring(docstring, description): {'type': 'number', 'multipleOf': 5}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ] },@@ -2276,7 +2276,7 @@ def test_constraints_schema_validation(kwargs, type_, expected_extra): Decimal, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ), (@@ -2284,7 +2284,7 @@ def test_constraints_schema_validation(kwargs, type_, expected_extra): Decimal, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ), (@@ -2292,7 +2292,7 @@ def test_constraints_schema_validation(kwargs, type_, expected_extra): Decimal, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ), (@@ -2300,7 +2300,7 @@ def test_constraints_schema_validation(kwargs, type_, expected_extra): Decimal, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ), (@@ -2308,7 +2308,7 @@ def test_constraints_schema_validation(kwargs, type_, expected_extra): Decimal, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ), ],@@ -6185,14 +6185,14 @@ def test_generate_definitions_for_no_ref_schemas(): { ('Decimal', 'serialization'): { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ('Decimal', 'validation'): { 'anyOf': [ {'type': 'number'}, { 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',+ 'pattern': '^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$', }, ] },@@ -7391,6 +7391,57 @@ def test_decimal_pattern_reject_invalid_not_numerical_values_with_decimal_places assert re.fullmatch(pattern, invalid_decimal) is None +@pytest.mark.parametrize(+ 'max_digits,decimal_places,valid,invalid',+ [+ (None, None, ['1', '-1.5', '.5', '+0.', '0010.0100'], ['', '.', '-', '+-', '1.1.1', 'a']),+ (None, 2, ['1', '-1.5', '.5', '11111.1100'], ['', '.', '0.001', '1.111']),+ (None, 0, ['1', '1.', '1.000', '.0'], ['', '.', '1.5', '.1']),+ (3, None, ['111', '0.001000', '011.10', '+.123'], ['', '.', '1111', '111.1', '0.0001']),+ (4, 2, ['10.01', '0011', '.11000', '00011.'], ['', '.', '111', '10.001', '.111']),+ (4, 4, ['0.3333', '+000.000100'], ['', '.', '1.', '0.33333']),+ (2, 4, ['0.12', '.10000'], ['', '.', '1', '0.123']),+ (5, 0, ['12345', '12345.000'], ['', '.', '123456', '1.5']),+ ],+)+def test_decimal_pattern_is_supported_by_pydantic_core(+ max_digits, decimal_places, valid, invalid, get_decimal_pattern+) -> None:+ """The emitted pattern must not use look-around, so that it can be compiled by pydantic-core's Rust regex engine.++ See https://github.com/pydantic/pydantic/issues/13017 for context.+ """+ pattern = get_decimal_pattern(max_digits=max_digits, decimal_places=decimal_places)++ ta = TypeAdapter(Annotated[str, StringConstraints(pattern=pattern)])++ for value in valid:+ assert ta.validate_python(value) == value+ # JSON Schema patterns are not implicitly anchored:+ assert re.search(pattern, value) is not None+ for value in invalid:+ with pytest.raises(ValidationError):+ ta.validate_python(value)+ assert re.search(pattern, value) is None+++def test_decimal_model_json_schema_pattern_roundtrips_through_pydantic_core() -> None:+ class MyModel(BaseModel):+ amount: Decimal++ schema = MyModel.model_json_schema()+ string_variant = next(v for v in schema['properties']['amount']['anyOf'] if v.get('type') == 'string')++ ta = TypeAdapter(Annotated[str, StringConstraints(pattern=string_variant['pattern'])])+ assert ta.validate_python('-12.34') == '-12.34'+ with pytest.raises(ValidationError):+ ta.validate_python('.')++ serialization_pattern = MyModel.model_json_schema(mode='serialization')['properties']['amount']['pattern']+ ta = TypeAdapter(Annotated[str, StringConstraints(pattern=serialization_pattern)])+ assert ta.validate_python('12.34') == '12.34'++ def test_union_format_primitive_type_array() -> None: class Sub(BaseModel): pass
docs/api/standard_library_types.mdindex 4070fda59..5802bb2e3 100644@@ -300,11 +300,48 @@ Decimals support the following constraints (numbers must be coercible to decimal | `gt` | The value must be strictly greater than this number | [`exclusiveMinimum`](https://json-schema.org/understanding-json-schema/reference/numeric#range) keyword | | `multiple_of` | The value must be a multiple of this number | [`multipleOf`](https://json-schema.org/understanding-json-schema/reference/numeric#multiples) keyword | | `allow_inf_nan` | Whether to allow NaN (not-a-number) and infinite values | N/A |-| `max_digits` | The maximum number of decimal digits allowed. The zero before the decimal point and trailing zeros are not counted. | [`pattern`](https://json-schema.org/understanding-json-schema/reference/string#regexp) keyword, to describe the string pattern |-| `decimal_places` | The maximum number of decimal places allowed. Trailing zeros are not counted. | [`pattern`](https://json-schema.org/understanding-json-schema/reference/string#regexp) keyword, to describe the string pattern |+| `max_digits` | The maximum number of decimal digits allowed. The zero before the decimal point and trailing zeros are not counted. | N/A (see below) |+| `decimal_places` | The maximum number of decimal places allowed. Trailing zeros are not counted. | N/A (see below) | -Note that the JSON Schema [`pattern`](https://json-schema.org/understanding-json-schema/reference/string#regexp) keyword will be specified-in the JSON Schema to describe the string pattern in all cases (and can vary if `max_digits` and/or `decimal_places` is specified).+/// version-changed | v2.12+The JSON Schema includes a [`pattern`](https://json-schema.org/understanding-json-schema/reference/string#regexp) matching the `max_digits`+and `decimal_places` constraints.+///++/// version-changed | v2.14+The JSON Schema no longer includes a [`pattern`](https://json-schema.org/understanding-json-schema/reference/string#regexp) by default,+as the generated pattern can cause issues for downstream consumers due to its complexity.++The pattern can be included by subclassing [`GenerateJsonSchema`][pydantic.json_schema.GenerateJsonSchema] and overriding the+[`get_decimal_pattern()`][pydantic.json_schema.GenerateJsonSchema.get_decimal_pattern] method:++```python+from decimal import Decimal+from typing import Annotated++from pydantic import Field, TypeAdapter+from pydantic.json_schema import GenerateJsonSchema+++class MyGenerateJsonSchema(GenerateJsonSchema):+ def get_decimal_pattern(self, schema):+ return self.build_decimal_pattern(schema)+++ta = TypeAdapter(Annotated[Decimal, Field(max_digits=5, decimal_places=2)])+print(+ ta.json_schema(schema_generator=MyGenerateJsonSchema, mode='serialization')+)+"""+{+ 'pattern': '^-?(?:(?:0|[1-9][0-9]{0,2})(?:\\.[0-9]{1,2}0*)?|0E[+-][1-9][0-9]*|[1-9](?:\\.[0-9]+)?E\\+[1-2])$',+ 'type': 'string',+}+"""+```++The generated pattern also no longer uses lookahead assertions, and takes exponents and `allow_inf_nan` into account.+/// These constraints can be provided using the [`Field()`][pydantic.Field] function. The `Le`, `Ge`, `Lt`, `Gt` and `MultipleOf` metadata types from the [`annotated-types`](https://github.com/annotated-types/annotated-types)docs/concepts/json_schema.mdindex cd8bc01a8..e0a7bdf4c 100644@@ -275,13 +275,7 @@ print(Model.model_json_schema(mode='validation')) { 'properties': { 'a': {- 'anyOf': [- {'type': 'number'},- {- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- 'type': 'string',- },- ],+ 'anyOf': [{'type': 'number'}, {'type': 'string'}], 'default': '12.34', 'title': 'A', }@@ -294,14 +288,7 @@ print(Model.model_json_schema(mode='validation')) print(Model.model_json_schema(mode='serialization')) """ {- 'properties': {- 'a': {- 'default': '12.34',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- 'title': 'A',- 'type': 'string',- }- },+ 'properties': {'a': {'default': '12.34', 'title': 'A', 'type': 'string'}}, 'title': 'Model', 'type': 'object', }pydantic/json_schema.pyindex 8135c60b5..5c585426d 100644@@ -723,49 +723,11 @@ class GenerateJsonSchema: Returns: The generated JSON schema. """-- def get_decimal_pattern(schema: core_schema.DecimalSchema) -> str:- max_digits = schema.get('max_digits')- decimal_places = schema.get('decimal_places')-- pattern = (- r'^(?!^[-+.]*$)[+-]?0*' # check it is not empty string and not one or sequence of ".+-" characters.- )-- # Case 1: Both max_digits and decimal_places are set- if max_digits is not None and decimal_places is not None:- integer_places = max(0, max_digits - decimal_places)- pattern += (- rf'(?:'- rf'\d{{0,{integer_places}}}'- rf'|'- rf'(?=[\d.]{{1,{max_digits + 1}}}0*$)'- rf'\d{{0,{integer_places}}}\.\d{{0,{decimal_places}}}0*$'- rf')'- )-- # Case 2: Only max_digits is set- elif max_digits is not None and decimal_places is None:- pattern += (- rf'(?:'- rf'\d{{0,{max_digits}}}'- rf'|'- rf'(?=[\d.]{{1,{max_digits + 1}}}0*$)'- rf'\d*\.\d*0*$'- rf')'- )-- # Case 3: Only decimal_places is set- elif max_digits is None and decimal_places is not None:- pattern += rf'\d*\.?\d{{0,{decimal_places}}}0*$'-- # Case 4: Both are None (no restrictions)- else:- pattern += r'\d*\.?\d*$' # look for arbitrary integer or decimal-- return pattern-- json_schema = self.str_schema(core_schema.str_schema(pattern=get_decimal_pattern(schema)))+ str_schema = core_schema.str_schema()+ pattern = self.get_decimal_pattern(schema)+ if pattern is not None:+ str_schema['pattern'] = pattern+ json_schema = self.str_schema(str_schema) if self.mode == 'validation': multiple_of = schema.get('multiple_of') le = schema.get('le')@@ -789,6 +751,63 @@ class GenerateJsonSchema: } return json_schema + def get_decimal_pattern(self, schema: core_schema.DecimalSchema) -> str | None:+ """Get the regular expression pattern to apply to the string representation of a decimal.++ By default, no pattern is applied (`None` is returned). Subclasses can override this method+ to return a custom pattern, or [`build_decimal_pattern()`][pydantic.json_schema.GenerateJsonSchema.build_decimal_pattern]+ can be used to get a pattern reflecting the `max_digits` and `decimal_places` constraints:++ ```python+ from pydantic.json_schema import GenerateJsonSchema++ class MyGenerateJsonSchema(GenerateJsonSchema):+ def get_decimal_pattern(self, schema):+ return self.build_decimal_pattern(schema)+ ```++ Args:+ schema: The core schema.++ Returns:+ The regular expression pattern, or `None` if no pattern should be applied.+ """+ return None++ def build_decimal_pattern(self, schema: core_schema.DecimalSchema) -> str:+ """Build a regular expression pattern for the string representation of a decimal.++ The pattern takes into account the `max_digits` and `decimal_places` constraints, and the current+ mode:++ - In `'validation'` mode, the pattern accepts the string syntax understood by the [`Decimal`][decimal.Decimal]+ constructor. The `max_digits` and `decimal_places` constraints are only reflected for strings+ *without* an exponent: strings using an exponent are accepted as long as they are syntactically valid,+ as the constraints can't be expressed with a regular expression in this case.+ - In `'serialization'` mode, the pattern exactly describes the strings produced by pydantic+ (i.e. by `str(decimal)`) for decimals satisfying the constraints,+ including the ones using scientific notation (e.g. `'1E-7'`, `'1.5E+3'`).++ In both modes, trailing zeros in the decimal part are not counted (e.g. `'1.10'` is accepted with+ `decimal_places=1`), consistent with the validation behavior. If `allow_inf_nan` is enabled (on the+ core schema or in the configuration), the string representations of infinity and NaN are also accepted.++ Args:+ schema: The core schema.++ Returns:+ The regular expression pattern.+ """+ max_digits = schema.get('max_digits')+ decimal_places = schema.get('decimal_places')+ allow_inf_nan = schema.get('allow_inf_nan')+ if allow_inf_nan is None:+ allow_inf_nan = self._config.config_dict.get('allow_inf_nan', False)+ if self.mode == 'validation':+ return _decimal_validation_pattern(max_digits, decimal_places, allow_inf_nan)+ else:+ return _decimal_serialization_pattern(max_digits, decimal_places, allow_inf_nan)+ def str_schema(self, schema: core_schema.StringSchema) -> JsonSchemaValue: """Generates a JSON schema that matches a string value. @@ -2773,15 +2792,153 @@ def models_json_schema( # ##### End JSON Schema Generation Functions ##### -_HashableJsonValue: TypeAlias = (- int | float | str | bool | None | tuple['_HashableJsonValue', ...] | tuple[tuple[str, '_HashableJsonValue'], ...]-)+# Decimal JSON Schema pattern utilities.+# Note: while we could use `\d` to represent digits (`Decimal` objects allow Unicode decimal digits), we use [0-9] instead:+# - to reduce complexity (`\d` expands to a large set, and with `max_digits`/`decimal_places` constraints set, it can blow+# the compile limit on some engines).+# - [0-9] is a portable pattern (e.g. `\d` is equivalent to `[0-9]` in ECMA (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Character_class_escape#d)+# while it allows any Unicode decimal digit in Python.+++def _repeat(atom: str, min_count: int, max_count: int) -> str:+ """Build a regex repetition of `atom` between `min_count` and `max_count` times (inclusive), using the shortest quantifier."""+ if min_count > max_count or max_count == 0:+ return ''+ if min_count == max_count:+ return atom if min_count == 1 else f'{atom}{{{min_count}}}'+ if (min_count, max_count) == (0, 1):+ return f'{atom}?'+ return f'{atom}{{{min_count},{max_count}}}'+++def _int_range_pattern(max_value: int) -> str:+ """Build a regex matching the integers between 1 and `max_value` (inclusive), without leading zeros."""+ digits = str(max_value)+ length = len(digits)+ alts: list[str] = [f'[1-9]{_repeat("[0-9]", k - 1, k - 1)}' for k in range(1, length)]+ for i, char in enumerate(digits):+ d = int(char)+ low = 1 if i == 0 else 0+ high = d if i == length - 1 else d - 1+ if high >= low:+ char_class = str(low) if low == high else f'[{low}-{high}]'+ alts.append(f'{digits[:i]}{char_class}{_repeat("[0-9]", length - i - 1, length - i - 1)}')+ return alts[0] if len(alts) == 1 else f'(?:{"|".join(alts)})'+++def _decimal_validation_pattern(max_digits: int | None, decimal_places: int | None, allow_inf_nan: bool) -> str:+ """Build the decimal pattern for the `'validation'` mode."""++ number = r'(?:[0-9]+\.?[0-9]*|\.[0-9]+)' # e.g. 1, 1., .5+ exponent = r'[eE][+-]?[0-9]+' # e.g. e5, E5, e-7+ # e.g. Infinity, inf, NaN, sNaN, NaN123 (case-insensitive). Spelled out explicitly, as inline flags+ # aren't supported by all regular expression engines:+ non_finite = r'|[iI][nN][fF](?:[iI][nN][iI][tT][yY])?|[sS]?[nN][aA][nN][0-9]*' if allow_inf_nan else ''+ if max_digits is None and decimal_places is None:+ return rf'^[+-]?(?:{number}(?:{exponent})?{non_finite})$'++ alts: list[str] = []+ if max_digits is not None and decimal_places is not None:+ # If `decimal_places > max_digits`, no whole digits are allowed and `max_digits` bounds the decimal places:+ whole = max(0, max_digits - decimal_places)+ places = min(max_digits, decimal_places)+ int_part = f'0*{_repeat("[0-9]", 1, whole)}' if whole else '0+'+ opt_int_part = f'0*{_repeat("[0-9]", 0, whole)}'+ opt_frac_part = rf'\.{_repeat("[0-9]", 0, places)}0*'+ frac_part = rf'\.{_repeat("[0-9]", 1, places)}0*' if places else r'\.0+'+ alts += [f'{int_part}(?:{opt_frac_part})?', f'{opt_int_part}{frac_part}']+ elif max_digits is not None:+ # The whole part and decimal part must have at most `max_digits` digits in total,+ # so we enumerate the possible widths of the whole part:+ int_part = f'0*{_repeat("[0-9]", 1, max_digits)}' if max_digits else '0+'+ alts.append(rf'{int_part}(?:\.0*)?')+ alts += [+ rf'0*{_repeat("[0-9]", whole, whole)}\.{_repeat("[0-9]", 1, max_digits - whole)}0*'+ for whole in range(max_digits)+ ] or [r'0*\.0+']+ else:+ assert decimal_places is not None+ opt_frac_part = rf'\.{_repeat("[0-9]", 0, decimal_places)}0*'+ frac_part = rf'\.{_repeat("[0-9]", 1, decimal_places)}0*' if decimal_places else r'\.0+'+ alts += [f'[0-9]+(?:{opt_frac_part})?', f'[0-9]*{frac_part}']++ alts.append(f'{number}{exponent}')+ return rf'^[+-]?(?:{"|".join(alts)}{non_finite})$'+++def _decimal_serialization_pattern(max_digits: int | None, decimal_places: int | None, allow_inf_nan: bool) -> str:+ """Build the decimal pattern for the `'serialization'` mode.++ Decimals are serialized using `str()`, producing either:++ - The plain notation (`'123.45'`), when the exponent is lower than or equal to 0 and the adjusted+ exponent is greater than or equal to -6.+ - The scientific notation otherwise (`'1E+3'`, `'1.5E-7'`, `'0E-10'`), with a single digit before+ the optional decimal point and an always signed exponent.++ Trailing zeros of the decimal part are preserved by `str()`, but aren't counted by the validation logic.+ """++ def frac_part(places: int) -> str:+ return rf'\.{_repeat("[0-9]", 1, places)}0*' if places else r'\.0+'++ alts: list[str] = []++ # Plain notation:+ if max_digits is not None and decimal_places is not None:+ whole = max(0, max_digits - decimal_places)+ places = min(max_digits, decimal_places)+ int_part = f'(?:0|[1-9]{_repeat("[0-9]", 0, whole - 1)})' if whole else '0'+ alts.append(f'{int_part}(?:{frac_part(places)})?')+ elif max_digits is not None:+ # The whole part and decimal part must have at most `max_digits` digits in total,+ # so we enumerate the possible widths of the whole part:+ alts.append(rf'0(?:\.{_repeat("[0-9]", 1, max_digits)}0*)?')+ alts += [+ f'[1-9]{_repeat("[0-9]", whole - 1, whole - 1)}(?:{frac_part(max_digits - whole)})?'+ for whole in range(1, max_digits + 1)+ ]+ elif decimal_places is not None:+ alts.append(f'(?:0|[1-9][0-9]*)(?:{frac_part(decimal_places)})?')+ else:+ alts.append(r'(?:0|[1-9][0-9]*)(?:\.[0-9]+)?')++ # Zero with an exponent (e.g. `'0E-10'`), which normalizes to zero and thus satisfies any constraint:+ alts.append(r'0E[+-][1-9][0-9]*')++ # Scientific notation with a positive exponent `k` (e.g. `'1.5E+3'`): the value has `k + 1` whole digits+ # and no decimal places:+ if max_digits is None:+ alts.append(r'[1-9](?:\.[0-9]+)?E\+[1-9][0-9]*')+ else:+ max_exponent = max_digits - (decimal_places or 0) - 1+ if max_exponent >= 1:+ alts.append(rf'[1-9](?:\.[0-9]+)?E\+{_int_range_pattern(max_exponent)}')++ # Scientific notation with a negative exponent `k` (`k >= 7`, e.g. `'1.5E-7'`): the value has no whole digits,+ # and `k` + (the number of significant decimal digits of the coefficient) decimal places:+ if max_digits is None and decimal_places is None:+ alts.append(r'[1-9](?:\.[0-9]+)?E-[1-9][0-9]*')+ else:+ max_places = min(c for c in (max_digits, decimal_places) if c is not None)+ alts += [f'[1-9](?:{frac_part(max_places - k)})?E-{k}' for k in range(7, max_places + 1)]++ if allow_inf_nan:+ # `str()` produces `'Infinity'`, `'NaN'` and `'sNaN'` (with an optional payload):+ alts += ['Infinity', 's?NaN[0-9]*']++ return rf'^-?(?:{"|".join(alts)})$' def _deduplicate_schemas(schemas: Iterable[JsonDict]) -> list[JsonDict]: return list({_make_json_hashable(schema): schema for schema in schemas}.values()) +_HashableJsonValue: TypeAlias = (+ int | float | str | bool | None | tuple['_HashableJsonValue', ...] | tuple[tuple[str, '_HashableJsonValue'], ...]+)++ def _make_json_hashable(value: JsonValue) -> _HashableJsonValue: if isinstance(value, dict): return tuple(sorted((k, _make_json_hashable(v)) for k, v in value.items()))tests/test_json_schema.pyindex b1907b720..bb38003f8 100644@@ -36,6 +36,7 @@ from typing_extensions import TypeAliasType, TypedDict, deprecated import pydantic from pydantic import ( AfterValidator,+ AllowInfNan, BaseModel, BeforeValidator, Field,@@ -64,6 +65,7 @@ from pydantic.json_schema import ( DEFAULT_REF_TEMPLATE, Examples, GenerateJsonSchema,+ JsonSchemaMode, JsonSchemaValue, NoDefault, PydanticJsonSchemaWarning,@@ -562,10 +564,7 @@ def test_decimal_json_schema(): 'b': { 'anyOf': [ {'type': 'number'},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ], 'default': '12.34', 'title': 'B',@@ -581,7 +580,6 @@ def test_decimal_json_schema(): 'default': '12.34', 'title': 'B', 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$', }, }, 'title': 'Model',@@ -1170,10 +1168,7 @@ def test_special_decimal_types(field_type, expected_schema): 'a': { 'anyOf': [ {'type': 'number'},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ], 'title': 'A', }@@ -2173,10 +2168,7 @@ def test_docstring(docstring, description): { 'anyOf': [ {'exclusiveMinimum': 2.0, 'type': 'number'},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ] }, ),@@ -2186,10 +2178,7 @@ def test_docstring(docstring, description): { 'anyOf': [ {'type': 'number', 'exclusiveMaximum': 5},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ] }, ),@@ -2199,10 +2188,7 @@ def test_docstring(docstring, description): { 'anyOf': [ {'type': 'number', 'minimum': 2},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ] }, ),@@ -2212,10 +2198,7 @@ def test_docstring(docstring, description): { 'anyOf': [ {'type': 'number', 'maximum': 5},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ] }, ),@@ -2225,10 +2208,7 @@ def test_docstring(docstring, description): { 'anyOf': [ {'type': 'number', 'multipleOf': 5},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ] }, ),@@ -2274,42 +2254,27 @@ def test_constraints_schema_validation(kwargs, type_, expected_extra): ( {'gt': 2}, Decimal,- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ), ( {'lt': 5}, Decimal,- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ), ( {'ge': 2}, Decimal,- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ), ( {'le': 5}, Decimal,- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ), ( {'multiple_of': 5}, Decimal,- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ), ], )@@ -6183,17 +6148,11 @@ def test_generate_definitions_for_no_ref_schemas(): ) assert result == ( {- ('Decimal', 'serialization'): {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ ('Decimal', 'serialization'): {'type': 'string'}, ('Decimal', 'validation'): { 'anyOf': [ {'type': 'number'},- {- 'type': 'string',- 'pattern': '^(?!^[-+.]*$)[+-]?0*\\d*\\.?\\d*$',- },+ {'type': 'string'}, ] }, ('Model', 'validation'): {'$ref': '#/$defs/Model'},@@ -7281,15 +7240,42 @@ def test_json_schema_arguments_v3_aliases() -> None: } +class DecimalPatternGenerateJsonSchema(GenerateJsonSchema):+ def get_decimal_pattern(self, schema: core_schema.DecimalSchema) -> str | None:+ return self.build_decimal_pattern(schema)++ @pytest.fixture def get_decimal_pattern():- def pattern(max_digits=None, decimal_places=None) -> str:- filed = TypeAdapter(Annotated[Decimal, Field(max_digits=max_digits, decimal_places=decimal_places)])- return filed.json_schema()['anyOf'][1]['pattern']+ def pattern(max_digits=None, decimal_places=None, mode: JsonSchemaMode = 'validation') -> str:+ ta = TypeAdapter(Annotated[Decimal, Field(max_digits=max_digits, decimal_places=decimal_places)])+ json_schema = ta.json_schema(schema_generator=DecimalPatternGenerateJsonSchema, mode=mode)+ if mode == 'validation':+ json_schema = json_schema['anyOf'][1]+ return json_schema['pattern'] return pattern +def test_decimal_pattern_not_set_by_default() -> None:+ ta = TypeAdapter(Annotated[Decimal, Field(max_digits=4, decimal_places=2)])++ assert ta.json_schema() == {'anyOf': [{'type': 'number'}, {'type': 'string'}]}+ assert ta.json_schema(mode='serialization') == {'type': 'string'}+++def test_decimal_pattern_custom() -> None:+ class CustomGenerateJsonSchema(GenerateJsonSchema):+ def get_decimal_pattern(self, schema: core_schema.DecimalSchema) -> str | None:+ return rf'^\d{{1,{schema["max_digits"]}}}$'++ ta = TypeAdapter(Annotated[Decimal, Field(max_digits=4)])++ assert ta.json_schema(schema_generator=CustomGenerateJsonSchema) == {+ 'anyOf': [{'type': 'number'}, {'type': 'string', 'pattern': r'^\d{1,4}$'}]+ }++ @pytest.mark.parametrize('valid_decimal', ['0.1', '0000.1', '11.1', '001.1', '11111111.1', '0.100000', '0.01', '0.11']) def test_decimal_pattern_with_only_decimal_places_set(valid_decimal, get_decimal_pattern) -> None: decimal_places = 2@@ -7391,6 +7377,162 @@ def test_decimal_pattern_reject_invalid_not_numerical_values_with_decimal_places assert re.fullmatch(pattern, invalid_decimal) is None +@pytest.mark.parametrize(['max_digits', 'decimal_places'], [(None, None), (3, None), (None, 2), (4, 2)])+@pytest.mark.parametrize(+ 'valid_decimal', ['1e5', '1E5', '1E+5', '1e-5', '-1.5E1', '+.5e1', '1.e5', '01.10E01', '1.234E+1', '12345E-3']+)+def test_decimal_pattern_with_exponent(max_digits, decimal_places, valid_decimal, get_decimal_pattern) -> None:+ pattern = get_decimal_pattern(max_digits, decimal_places)++ assert re.fullmatch(pattern, valid_decimal) is not None+++@pytest.mark.parametrize(['max_digits', 'decimal_places'], [(None, None), (3, None), (None, 2), (4, 2)])+@pytest.mark.parametrize('invalid_decimal', ['e5', '.e5', '1e', '1e+', '1E5.0', '1.5.E5', '1e5e5', '1e1.5', '1f5'])+def test_decimal_pattern_reject_invalid_with_exponent(+ max_digits, decimal_places, invalid_decimal, get_decimal_pattern+) -> None:+ pattern = get_decimal_pattern(max_digits, decimal_places)++ assert re.fullmatch(pattern, invalid_decimal) is None+++@pytest.mark.parametrize(+ ['max_digits', 'decimal_places', 'valid_decimals'],+ [+ (+ None,+ None,+ [+ '0',+ '-0',+ '-0.0',+ '0.00',+ '12.34',+ '100',+ '0.000001',+ '1E-7',+ '1.5E-7',+ '0E-10',+ '0E+5',+ '1E+2',+ '1.0E+3',+ '-1.5E-100',+ '1E+100',+ ],+ ),+ (3, None, ['0', '0.100', '100', '10.0', '1.23', '0.001', '0.001000', '1E+2', '0E-10', '0E+15']),+ (None, 2, ['0', '1.23', '1.230000', '123456789.12', '0.10', '1E+2', '1.5E+3', '0E-10', '1E+100']),+ (5, 2, ['0', '-0.10', '123.45', '123.450', '999', '99.9', '1E+2', '1.5E+2', '0E-10']),+ (2, 3, ['0.0', '0.01', '0.010', '-0.01', '0E-10']),+ (10, 8, ['0', '99.12345678', '99.1234567800', '0.00000001', '1E-7', '1.5E-7', '1E-8', '1E+1', '0E-20']),+ (30, None, ['1E-7', '1.2345678901234567890123E-7', '1E-30', '1E+29', '123456789012345678901234567890']),+ (4, 0, ['0', '9999', '9999.0', '1E+3', '1.5E+3', '0E-10']),+ ],+)+def test_decimal_pattern_serialization(max_digits, decimal_places, valid_decimals, get_decimal_pattern) -> None:+ pattern = get_decimal_pattern(max_digits, decimal_places, mode='serialization')+ ta = TypeAdapter(Annotated[Decimal, Field(max_digits=max_digits, decimal_places=decimal_places)])++ for valid_decimal in valid_decimals:+ serialized = json.loads(ta.dump_json(ta.validate_python(valid_decimal)))+ assert serialized == str(Decimal(valid_decimal))+ assert re.fullmatch(pattern, serialized) is not None, valid_decimal+++@pytest.mark.parametrize(+ ['max_digits', 'decimal_places', 'invalid_decimals'],+ [+ # Not produced by `str()` (or not a decimal):+ (+ None,+ None,+ [+ '',+ '.',+ '-',+ '+1',+ '01',+ '1.',+ '.1',+ '-01.5',+ '1e5',+ '1E5',+ '1E-05',+ '1E+0',+ '0E-0',+ '00E-10',+ '10E+2',+ '0.0E+2',+ 'E5',+ 'Infinity',+ 'NaN',+ ],+ ),+ # Doesn't satisfy the constraints:+ (3, None, ['1000', '1.234', '0.0001', '1E+3', '1E-4', '1.5E+3', '1.5E-7']),+ (None, 2, ['1.234', '0.001', '1E-7', '1.5E-7', '0.001E+2']),+ (5, 2, ['1234', '123.456', '1000.5', '0.001', '1E+3', '1E-7']),+ (2, 3, ['1', '0.001', '1.0', '1E+1', '1E-7']),+ (10, 8, ['100', '99.123456789', '0.000000001', '1E-9', '1.5E-8', '1.23E-7', '1E+2']),+ (4, 0, ['0.1', '10000', '1E+4', '1E-7']),+ ],+)+def test_decimal_pattern_serialization_reject_invalid(+ max_digits, decimal_places, invalid_decimals, get_decimal_pattern+) -> None:+ pattern = get_decimal_pattern(max_digits, decimal_places, mode='serialization')++ for invalid_decimal in invalid_decimals:+ assert re.fullmatch(pattern, invalid_decimal) is None, invalid_decimal+++def test_decimal_pattern_allow_inf_nan() -> None:+ class Model(BaseModel):+ model_config = ConfigDict(allow_inf_nan=True)++ a: Decimal+ b: Annotated[Decimal, AllowInfNan(False)] = Decimal(0)++ class ModelNoConfig(BaseModel):+ a: Annotated[Decimal, AllowInfNan()]++ non_finite = ['Infinity', '-Infinity', 'inf', 'INF', '+Inf', 'NaN', 'nan', '-NaN', 'sNaN', 'snan', 'NaN123']++ for model, field in [(Model, 'a'), (ModelNoConfig, 'a')]:+ validation_pattern = model.model_json_schema(schema_generator=DecimalPatternGenerateJsonSchema)['properties'][+ field+ ]['anyOf'][1]['pattern']+ serialization_pattern = model.model_json_schema(+ schema_generator=DecimalPatternGenerateJsonSchema, mode='serialization'+ )['properties'][field]['pattern']++ for value in ['1.5', *non_finite]:+ assert re.fullmatch(validation_pattern, value) is not None, value+ serialized = model.model_validate({field: value}).model_dump(mode='json')[field]+ assert re.fullmatch(serialization_pattern, serialized) is not None, serialized++ for value in ['Infinity1', 'inf.0', 'in', 'NaN1.5', 'sInf', 'i n f']:+ assert re.fullmatch(validation_pattern, value) is None, value+ for value in ['inf', 'nan', 'INFINITY', '+Infinity', 'sNaN1.5', 'sInf']:+ assert re.fullmatch(serialization_pattern, value) is None, value++ # The schema takes precedence over the config:+ for mode in ('validation', 'serialization'):+ json_schema = Model.model_json_schema(schema_generator=DecimalPatternGenerateJsonSchema, mode=mode)+ pattern = json_schema['properties']['b']+ pattern = (pattern['anyOf'][1] if mode == 'validation' else pattern)['pattern']+ for value in non_finite:+ assert re.fullmatch(pattern, value) is None, value+++def test_decimal_pattern_allow_inf_nan_disabled_by_default(get_decimal_pattern) -> None:+ for mode in ('validation', 'serialization'):+ pattern = get_decimal_pattern(mode=mode)+ for value in ['Infinity', '-Infinity', 'inf', 'NaN', 'sNaN']:+ assert re.fullmatch(pattern, value) is None, value++ def test_union_format_primitive_type_array() -> None: class Sub(BaseModel): pass