Backtestspydanticrun-20260930-144322#13507
Experimental pipeline: every constraint chained after ge/lt/le is dropped from the JSON schema
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 reported schema bug the same basic way. The fallback `function-after` check is now skipped when the native core-schema field is set, so later constraints still see a numeric schema and land in the JSON schema. Both add the issue's JSON-schema cases (`ge(1).le(100)`, `le(100).ge(1)`, `Interval`, the `multiple_of` chain, `lt(100).gt(1)`).
The patches differ in how they guard the native path, and that decides it.
Patch A introduces a validation regression. It drops the type-matching checks and assigns the native field whenever the schema is int, float or decimal. It also never checks whether that field is already set. Because no wrapping happens anymore, a repeated constraint silently overwrites the earlier one:
- `validate_as(int).ge(5).ge(1)` ends up as `{'type': 'int', 'ge': 1}` and accepts 3.
- `.multiple_of(3).multiple_of(5)` enforces only 5.
Before Patch A, both constraints were enforced by the stacked function validators. So Patch A trades a schema-only bug for a real validation bug, which is the more serious failure the issue stressed was not present.
Patch A also relies on pydantic-core to coerce mismatched bound types. Its tests only use exactly-representable values like `ge(0.0)` on int. A fractional bound on an int schema (`ge(1.5)`) is either rejected at schema build or silently changed, and nothing tests that.
Patch B follows the `native_constraint_applied` shape the issue proposes, applied symmetrically to all five branches. It sets the native field only when the value type matches and the field is not already present. Otherwise it falls back to the function check, so:
- type mismatches are still enforced;
- repeated constraints stack instead of overwriting;
- the common chained cases get a correct native schema.
Patch B's tests cover exactly these edges: the issue's schema cases plus a float mixed-bound case, validation of the chained expression, type-mismatch fallbacks for all five constraints, and repeated-constraint enforcement. Patch A would fail the repeated-constraint tests.
Patch B is more verbose, but it is correct and consistent with the existing branching style.
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
4m 51s13 turns
Wall-clock time in the container
Full test suite
No new failures
12,293 passed · 501 skipped · 12,794 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
153vs 112 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial Checks
- I confirm that I'm using Pydantic V2
Description
In the experimental pipeline API, chaining constraints silently drops every bound after the first from the generated JSON schema. Validation stays correct - only the published schema is wrong, which makes it easy to miss.
All bounds below are non-zero, so this is not #13450 (falsy zero bounds in Interval). Observed identically on released 2.13.4 and on main (2.14.0a1).
| expression | JSON schema | validation |
|---|---|---|
validate_as(int).ge(1).le(100) | {"minimum": 1, "type": "integer"} | 0 reject, 50 accept, 200 reject |
validate_as(int).le(100).ge(1) | {"maximum": 100, "type": "integer"} | 0 reject, 50 accept, 200 reject |
validate_as(int).constrain(Interval(ge=1, le=100)) | {"minimum": 1, "type": "integer"} | 0 reject, 50 accept, 200 reject |
validate_as(int).ge(1).le(100).multiple_of(5) | {"minimum": 1, "type": "integer"} | correct |
validate_as(int).gt(1).lt(100) (control) | {"exclusiveMinimum": 1, "exclusiveMaximum": 100, ...} | correct |
Annotated[int, Ge(1), Le(100)] (control) | {"minimum": 1, "maximum": 100, ...} | correct |
So .ge(1).le(100).multiple_of(5) publishes a schema advertising any integer >= 1, while the validator rejects 200 and 52. For FastAPI that means the OpenAPI component and every generated client disagree with the server.
Cause
In _apply_constraint(), the Ge, Lt and Le branches apply their fallback function validator unconditionally - including when the native core-schema field was just set:
elif isinstance(constraint, annotated_types.Ge):
ge = constraint.ge
if s and s['type'] in {'int', 'float', 'decimal'}:
s = s.copy()
if s['type'] == 'int' and isinstance(ge, int):
s['ge'] = ge # native constraint applied...
...
def check_ge(v: Any) -> bool:
return v >= ge
s = _check_func(check_ge, f'>= {ge}', s) # ...and then wrapped anyway
_check_func wraps the schema in function-after. The next constraint in the chain sees s['type'] == 'function-after', which is not in {'int', 'float', 'decimal'}, so it cannot set its own native field and survives only inside an opaque callable that JSON-schema generation cannot read. Core schema for .ge(1).le(100):
{'type': 'function-after',
'function': ..., # <- le(100) lives in here, invisible to the schema
'schema': {'type': 'function-after',
'function': ..., # <- redundant ge check
'schema': {'type': 'int', 'ge': 1}}}
Gt is the control that works, and only by accident: its fallback sits in an else:, so nothing is wrapped when the native constraint applies.
Relationship to the open PRs in this function
Two in-flight PRs each fix one branch of this, for unrelated reasons, and between them they leave Ge, Lt and Le untouched:
- #13473 adds a
native_constraint_appliedflag toMultipleOfto avoid a float parity problem. Same shape as the fix needed here. - #13446 restructures
Gtso the fallback lands inside the numeric branch.
Worth flagging on the second one: #13446's description argues that Gt is uniquely broken and holds up Ge/Lt/Le/MultipleOf as the correct model, because they "always apply" the check and so enforce the bound on a type mismatch. That is true of validation, but always applying it is exactly what destroys the schema. Gt is uniquely broken for validation; the other four are broken for schema. Whichever way this is fixed, it probably wants to be one symmetric change across all five branches rather than three separate patches.
Example Code
from typing import Annotated
from pydantic import TypeAdapter
from pydantic.experimental.pipeline import validate_as
ta = TypeAdapter(Annotated[int, validate_as(int).ge(1).le(100)])
print(ta.json_schema()) # {'minimum': 1, 'type': 'integer'} <- no maximum
ta.validate_python(200) # ValidationError, as it should be
# control: the same constraints without the pipeline
import annotated_types
print(TypeAdapter(Annotated[int, annotated_types.Ge(1), annotated_types.Le(100)]).json_schema())
# {'maximum': 100, 'minimum': 1, 'type': 'integer'}
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.11.15 (main, Mar 3 2026, 09:26:23) [GCC 13.3.0]
platform: Linux-6.18.5-x86_64-with-glibc2.39
related packages: typing_extensions-4.16.0
commit: unknown
I have a PR ready that applies the native_constraint_applied shape from #13473 to Ge/Lt/Le, with regression tests that fail without it. Happy to open it, or to fold it into one of the existing PRs if you'd rather land a single change.
The two patches
pydantic/experimental/pipeline.pyindex b9668517..1a716088 100644@@ -486,15 +486,20 @@ def _apply_constraint( # noqa: C901 """Apply a single constraint to a schema.""" if isinstance(constraint, annotated_types.Gt): gt = constraint.gt- if s and s['type'] in {'int', 'float', 'decimal'}:+ native_constraint_applied = False+ if s and s['type'] in {'int', 'float', 'decimal'} and 'gt' not in s: s = s.copy() if s['type'] == 'int' and isinstance(gt, int): s['gt'] = gt+ native_constraint_applied = True elif s['type'] == 'float' and isinstance(gt, float): s['gt'] = gt+ native_constraint_applied = True elif s['type'] == 'decimal' and isinstance(gt, Decimal): s['gt'] = gt- else:+ native_constraint_applied = True++ if not native_constraint_applied: def check_gt(v: Any) -> bool: return v > gt@@ -502,49 +507,67 @@ def _apply_constraint( # noqa: C901 s = _check_func(check_gt, f'> {gt}', s) elif isinstance(constraint, annotated_types.Ge): ge = constraint.ge- if s and s['type'] in {'int', 'float', 'decimal'}:+ native_constraint_applied = False+ if s and s['type'] in {'int', 'float', 'decimal'} and 'ge' not in s: s = s.copy() if s['type'] == 'int' and isinstance(ge, int): s['ge'] = ge+ native_constraint_applied = True elif s['type'] == 'float' and isinstance(ge, float): s['ge'] = ge+ native_constraint_applied = True elif s['type'] == 'decimal' and isinstance(ge, Decimal): s['ge'] = ge+ native_constraint_applied = True++ if not native_constraint_applied: - def check_ge(v: Any) -> bool:- return v >= ge+ def check_ge(v: Any) -> bool:+ return v >= ge - s = _check_func(check_ge, f'>= {ge}', s)+ s = _check_func(check_ge, f'>= {ge}', s) elif isinstance(constraint, annotated_types.Lt): lt = constraint.lt- if s and s['type'] in {'int', 'float', 'decimal'}:+ native_constraint_applied = False+ if s and s['type'] in {'int', 'float', 'decimal'} and 'lt' not in s: s = s.copy() if s['type'] == 'int' and isinstance(lt, int): s['lt'] = lt+ native_constraint_applied = True elif s['type'] == 'float' and isinstance(lt, float): s['lt'] = lt+ native_constraint_applied = True elif s['type'] == 'decimal' and isinstance(lt, Decimal): s['lt'] = lt+ native_constraint_applied = True - def check_lt(v: Any) -> bool:- return v < lt+ if not native_constraint_applied: - s = _check_func(check_lt, f'< {lt}', s)+ def check_lt(v: Any) -> bool:+ return v < lt++ s = _check_func(check_lt, f'< {lt}', s) elif isinstance(constraint, annotated_types.Le): le = constraint.le- if s and s['type'] in {'int', 'float', 'decimal'}:+ native_constraint_applied = False+ if s and s['type'] in {'int', 'float', 'decimal'} and 'le' not in s: s = s.copy() if s['type'] == 'int' and isinstance(le, int): s['le'] = le+ native_constraint_applied = True elif s['type'] == 'float' and isinstance(le, float): s['le'] = le+ native_constraint_applied = True elif s['type'] == 'decimal' and isinstance(le, Decimal): s['le'] = le+ native_constraint_applied = True++ if not native_constraint_applied: - def check_le(v: Any) -> bool:- return v <= le+ def check_le(v: Any) -> bool:+ return v <= le - s = _check_func(check_le, f'<= {le}', s)+ s = _check_func(check_le, f'<= {le}', s) elif isinstance(constraint, annotated_types.Len): min_len = constraint.min_length max_len = constraint.max_length@@ -572,19 +595,25 @@ def _apply_constraint( # noqa: C901 s = _check_func(check_len, f'length >= {min_len} and length <= {max_len}', s) elif isinstance(constraint, annotated_types.MultipleOf): multiple_of = constraint.multiple_of- if s and s['type'] in {'int', 'float', 'decimal'}:+ native_constraint_applied = False+ if s and s['type'] in {'int', 'float', 'decimal'} and 'multiple_of' not in s: s = s.copy() if s['type'] == 'int' and isinstance(multiple_of, int): s['multiple_of'] = multiple_of+ native_constraint_applied = True elif s['type'] == 'float' and isinstance(multiple_of, float): s['multiple_of'] = multiple_of+ native_constraint_applied = True elif s['type'] == 'decimal' and isinstance(multiple_of, Decimal): s['multiple_of'] = multiple_of+ native_constraint_applied = True++ if not native_constraint_applied: - def check_multiple_of(v: Any) -> bool:- return v % multiple_of == 0+ def check_multiple_of(v: Any) -> bool:+ return v % multiple_of == 0 - s = _check_func(check_multiple_of, f'% {multiple_of} == 0', s)+ s = _check_func(check_multiple_of, f'% {multiple_of} == 0', s) elif isinstance(constraint, annotated_types.Timezone): tz = constraint.tz tests/test_pipeline.pyindex 00e42101..ea878780 100644@@ -343,6 +343,41 @@ def test_predicates() -> None: {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]}, {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]}, ),+ (+ Annotated[int, validate_as(int).ge(1).le(100)],+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ ),+ (+ Annotated[int, validate_as(int).le(100).ge(1)],+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ ),+ (+ Annotated[int, validate_as(int).constrain(Interval(ge=1, le=100))],+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ ),+ (+ Annotated[int, validate_as(int).ge(1).le(100).multiple_of(5)],+ {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+ {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+ ),+ (+ Annotated[int, validate_as(int).lt(100).gt(1)],+ {'type': 'integer', 'exclusiveMinimum': 1, 'exclusiveMaximum': 100},+ {'type': 'integer', 'exclusiveMinimum': 1, 'exclusiveMaximum': 100},+ ),+ (+ Annotated[int, validate_as(int).multiple_of(5).ge(1)],+ {'type': 'integer', 'minimum': 1, 'multipleOf': 5},+ {'type': 'integer', 'minimum': 1, 'multipleOf': 5},+ ),+ (+ Annotated[float, validate_as(float).ge(1.5).lt(10.5)],+ {'type': 'number', 'minimum': 1.5, 'exclusiveMaximum': 10.5},+ {'type': 'number', 'minimum': 1.5, 'exclusiveMaximum': 10.5},+ ), ( Annotated[list[int], validate_as(...).len(0, 100)], {'type': 'array', 'items': {'type': 'integer'}, 'maxItems': 100},@@ -376,6 +411,59 @@ def test_json_schema( assert schema == expected_ser_schema +def test_chained_numeric_constraints_validation() -> None:+ ta = TypeAdapter[int](Annotated[int, validate_as(int).ge(1).le(100).multiple_of(5)])+ assert ta.validate_python(50) == 50+ for v in (0, 200, 52):+ with pytest.raises(ValidationError):+ ta.validate_python(v)+++@pytest.mark.parametrize(+ 'pipeline, valid_cases, invalid_cases',+ [+ (validate_as(int).gt(1.5), [2, 100], [1, 0]),+ (validate_as(int).ge(1.5), [2, 100], [1, 0]),+ (validate_as(int).lt(1.5), [1, 0], [2, 100]),+ (validate_as(int).le(1.5), [1, 0], [2, 100]),+ (validate_as(int).multiple_of(1.5), [3, 0], [1, 2]),+ ],+)+def test_numeric_constraint_type_mismatch(+ pipeline: _Pipeline[Any, Any], valid_cases: list[Any], invalid_cases: list[Any]+) -> None:+ """Constraints whose value type doesn't match the schema type can't be set natively but must still apply."""+ ta = TypeAdapter[int](Annotated[int, pipeline])+ for x in valid_cases:+ assert ta.validate_python(x) == x+ for y in invalid_cases:+ with pytest.raises(ValidationError):+ ta.validate_python(y)+++@pytest.mark.parametrize(+ 'pipeline, valid_cases, invalid_cases',+ [+ (validate_as(int).ge(5).ge(1), [5], [3]),+ (validate_as(int).ge(1).ge(5), [5], [3]),+ (validate_as(int).gt(5).gt(1), [6], [3]),+ (validate_as(int).le(10).le(100), [10], [50]),+ (validate_as(int).lt(10).lt(100), [9], [50]),+ (validate_as(int).multiple_of(3).multiple_of(5), [15], [10, 9]),+ ],+)+def test_repeated_numeric_constraint(+ pipeline: _Pipeline[Any, Any], valid_cases: list[Any], invalid_cases: list[Any]+) -> None:+ """Chaining the same numeric constraint twice must enforce both, not let the second overwrite the first."""+ ta = TypeAdapter[int](Annotated[int, pipeline])+ for x in valid_cases:+ assert ta.validate_python(x) == x+ for y in invalid_cases:+ with pytest.raises(ValidationError):+ ta.validate_python(y)++ def test_transform_first_step() -> None: """Check that when transform() is used as the first step in a pipeline it run after parsing.""" ta = TypeAdapter[int](Annotated[int, transform(lambda x: x + 1)])
pydantic/experimental/pipeline.pyindex b96685172..806156842 100644@@ -8,7 +8,6 @@ import re from collections import deque from collections.abc import Callable, Container from dataclasses import dataclass-from decimal import Decimal from functools import cached_property, partial from re import Pattern from types import EllipsisType@@ -484,16 +483,13 @@ def _apply_constraint( # noqa: C901 s: cs.CoreSchema | None, constraint: _ConstraintAnnotation ) -> cs.CoreSchema: """Apply a single constraint to a schema."""+ # No casting of the constraints is necessary, as pydantic-core does it+ # when building the validator from the core schema: if isinstance(constraint, annotated_types.Gt): gt = constraint.gt if s and s['type'] in {'int', 'float', 'decimal'}: s = s.copy()- if s['type'] == 'int' and isinstance(gt, int):- s['gt'] = gt- elif s['type'] == 'float' and isinstance(gt, float):- s['gt'] = gt- elif s['type'] == 'decimal' and isinstance(gt, Decimal):- s['gt'] = gt+ s['gt'] = gt # pyright: ignore[reportGeneralTypeIssues] else: def check_gt(v: Any) -> bool:@@ -504,47 +500,35 @@ def _apply_constraint( # noqa: C901 ge = constraint.ge if s and s['type'] in {'int', 'float', 'decimal'}: s = s.copy()- if s['type'] == 'int' and isinstance(ge, int):- s['ge'] = ge- elif s['type'] == 'float' and isinstance(ge, float):- s['ge'] = ge- elif s['type'] == 'decimal' and isinstance(ge, Decimal):- s['ge'] = ge+ s['ge'] = ge # pyright: ignore[reportGeneralTypeIssues]+ else: - def check_ge(v: Any) -> bool:- return v >= ge+ def check_ge(v: Any) -> bool:+ return v >= ge - s = _check_func(check_ge, f'>= {ge}', s)+ s = _check_func(check_ge, f'>= {ge}', s) elif isinstance(constraint, annotated_types.Lt): lt = constraint.lt if s and s['type'] in {'int', 'float', 'decimal'}: s = s.copy()- if s['type'] == 'int' and isinstance(lt, int):- s['lt'] = lt- elif s['type'] == 'float' and isinstance(lt, float):- s['lt'] = lt- elif s['type'] == 'decimal' and isinstance(lt, Decimal):- s['lt'] = lt+ s['lt'] = lt # pyright: ignore[reportGeneralTypeIssues]+ else: - def check_lt(v: Any) -> bool:- return v < lt+ def check_lt(v: Any) -> bool:+ return v < lt - s = _check_func(check_lt, f'< {lt}', s)+ s = _check_func(check_lt, f'< {lt}', s) elif isinstance(constraint, annotated_types.Le): le = constraint.le if s and s['type'] in {'int', 'float', 'decimal'}: s = s.copy()- if s['type'] == 'int' and isinstance(le, int):- s['le'] = le- elif s['type'] == 'float' and isinstance(le, float):- s['le'] = le- elif s['type'] == 'decimal' and isinstance(le, Decimal):- s['le'] = le+ s['le'] = le # pyright: ignore[reportGeneralTypeIssues]+ else: - def check_le(v: Any) -> bool:- return v <= le+ def check_le(v: Any) -> bool:+ return v <= le - s = _check_func(check_le, f'<= {le}', s)+ s = _check_func(check_le, f'<= {le}', s) elif isinstance(constraint, annotated_types.Len): min_len = constraint.min_length max_len = constraint.max_length@@ -574,17 +558,13 @@ def _apply_constraint( # noqa: C901 multiple_of = constraint.multiple_of if s and s['type'] in {'int', 'float', 'decimal'}: s = s.copy()- if s['type'] == 'int' and isinstance(multiple_of, int):- s['multiple_of'] = multiple_of- elif s['type'] == 'float' and isinstance(multiple_of, float):- s['multiple_of'] = multiple_of- elif s['type'] == 'decimal' and isinstance(multiple_of, Decimal):- s['multiple_of'] = multiple_of+ s['multiple_of'] = multiple_of # pyright: ignore[reportGeneralTypeIssues]+ else: - def check_multiple_of(v: Any) -> bool:- return v % multiple_of == 0+ def check_multiple_of(v: Any) -> bool:+ return v % multiple_of == 0 - s = _check_func(check_multiple_of, f'% {multiple_of} == 0', s)+ s = _check_func(check_multiple_of, f'% {multiple_of} == 0', s) elif isinstance(constraint, annotated_types.Timezone): tz = constraint.tz tests/test_pipeline.pyindex 00e421012..7198d4302 100644@@ -34,15 +34,30 @@ def test_parse_str_with_pattern() -> None: (int, validate_as(...).ge(0), [0, 1, 100], [-1, -100]), (float, validate_as(...).ge(0.0), [1.8, 0.0], [-1.0]), (Decimal, validate_as(...).ge(Decimal(0.0)), [Decimal(1), Decimal(0.0)], [Decimal(-1.0)]),+ (float, validate_as(float).ge(0), [1.8, 0.0], [-1.0]),+ (Decimal, validate_as(Decimal).ge(0), [Decimal(1), Decimal(0)], [Decimal(-1)]), # pyright: ignore[reportArgumentType]+ (int, validate_as(int).ge(0.0), [0, 1, 100], [-1, -100]), # pyright: ignore[reportArgumentType]+ # The `transform()` step results in a non-numeric core schema, meaning the constraint+ # is applied as a function check:+ (int, validate_as(int).transform(lambda x: x).ge(0), [0, 1, 100], [-1, -100]), (int, validate_as(...).le(5), [2, 4], [6, 100]), (float, validate_as(...).le(1.0), [0.5, 0.0], [100.0]), (Decimal, validate_as(...).le(Decimal(1.0)), [Decimal(1)], [Decimal(5.0)]),+ (float, validate_as(float).le(1), [0.5, 0.0], [100.0]),+ (Decimal, validate_as(Decimal).le(1), [Decimal(1)], [Decimal(5)]), # pyright: ignore[reportArgumentType]+ (int, validate_as(int).le(5.0), [2, 4], [6, 100]), # pyright: ignore[reportArgumentType] (int, validate_as(...).gt(0), [1, 2, 100], [0, -1]), (float, validate_as(...).gt(0.0), [0.1, 1.8], [0.0, -1.0]), (Decimal, validate_as(...).gt(Decimal(0.0)), [Decimal(1)], [Decimal(0.0), Decimal(-1.0)]),+ (float, validate_as(float).gt(0), [1.0, 2.5], [0.0, -1.0]),+ (Decimal, validate_as(Decimal).gt(0), [Decimal(1)], [Decimal(0), Decimal(-1)]), # pyright: ignore[reportArgumentType]+ (int, validate_as(int).gt(0.0), [1, 2], [0, -3]), # pyright: ignore[reportArgumentType] (int, validate_as(...).lt(5), [2, 4], [5, 6, 100]), (float, validate_as(...).lt(1.0), [0.5, 0.0], [1.0, 100.0]), (Decimal, validate_as(...).lt(Decimal(1.0)), [Decimal(0.5)], [Decimal(1.0), Decimal(5.0)]),+ (float, validate_as(float).lt(1), [0.5, 0.0], [1.0, 100.0]),+ (Decimal, validate_as(Decimal).lt(1), [Decimal('0.5')], [Decimal(1), Decimal(5)]), # pyright: ignore[reportArgumentType]+ (int, validate_as(int).lt(5.0), [2, 4], [5, 6, 100]), # pyright: ignore[reportArgumentType] ], ) def test_ge_le_gt_lt(@@ -61,6 +76,12 @@ def test_ge_le_gt_lt( [ (int, validate_as(int).multiple_of(5), [5, 20, 0], [18, 7]), (float, validate_as(float).multiple_of(2.5), [2.5, 5.0, 7.5], [3.0, 1.1]),+ (float, validate_as(float).multiple_of(2), [2.0, 4.0, 6.0], [3.0, 1.1]),+ (Decimal, validate_as(Decimal).multiple_of(2), [Decimal(2), Decimal(4)], [Decimal(3), Decimal('1.1')]), # pyright: ignore[reportArgumentType]+ (int, validate_as(int).multiple_of(5.0), [5, 20, 0], [18, 7]), # pyright: ignore[reportArgumentType]+ # The `transform()` step results in a non-numeric core schema, meaning the constraint+ # is applied as a function check:+ (int, validate_as(int).transform(lambda x: x).multiple_of(5), [5, 20, 0], [18, 7]), ( Decimal, validate_as(Decimal).multiple_of(Decimal('1.5')),@@ -338,6 +359,31 @@ def test_predicates() -> None: {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100}, {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100}, ),+ (+ Annotated[int, validate_as(int).ge(1).le(100)],+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ ),+ (+ Annotated[int, validate_as(int).le(100).ge(1)],+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ ),+ (+ Annotated[int, validate_as(int).constrain(Interval(ge=1, le=100))],+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ {'type': 'integer', 'minimum': 1, 'maximum': 100},+ ),+ (+ Annotated[int, validate_as(int).ge(1).le(100).multiple_of(5)],+ {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+ {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+ ),+ (+ Annotated[int, validate_as(int).lt(100).gt(1)],+ {'type': 'integer', 'exclusiveMinimum': 1, 'exclusiveMaximum': 100},+ {'type': 'integer', 'exclusiveMinimum': 1, 'exclusiveMaximum': 100},+ ), ( Annotated[int, validate_as(int).gt(0) | validate_as(int).lt(100)], {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]},
What the agent reported
I fixed the bug: chained constraints like .ge(1).le(100) now all appear in the JSON schema, and validation still enforces every bound. The pipeline tests (88), tests/test_types.py, tests/test_json_schema.py and tests/test_docs.py all pass. The changes are uncommitted in the working tree.
What was wrong
In _apply_constraint (pydantic/experimental/pipeline.py), the Ge, Lt, Le and MultipleOf branches always wrapped the schema in a function-after validator, even after setting the bound directly on the numeric schema. The next constraint in the chain then saw a function-after schema instead of an int/float/decimal one. It could only be enforced through an opaque function that JSON-schema generation can't read, so it vanished from the schema while validation stayed correct.
Gt had the opposite problem, which is a validation bug. On a numeric schema where the bound's type doesn't match (e.g. an int schema with gt(1.5)), it set nothing and added no check, so the constraint was silently dropped: validate_as(int).gt(1.5) accepted 1.
What I changed
- One symmetric change across all five branches (Gt, Ge, Lt, Le, MultipleOf), using the
native_constraint_appliedflag the report points to from #13473. The fallback check is only added when the bound wasn't set directly on the schema. - A fix for a problem the first change introduced, found in review. With the fallback gone, chaining the same constraint twice let the second value overwrite the first:
.ge(5).ge(1)accepted 3. Each branch now sets the bound directly only if that field isn't already set; otherwise it adds the fallback check. Before this change the same overwrite already happened for.gt(5).gt(1), and that is fixed too.
Tests added (tests/test_pipeline.py)
- Seven new
test_json_schemacases, checking both validation and serialization schemas. They coverge(1).le(100),le(100).ge(1),constrain(Interval(ge=1, le=100)),ge(1).le(100).multiple_of(5),lt(100).gt(1),multiple_of(5).ge(1)and floatge(1.5).lt(10.5). All seven failed before the fix and pass now. test_chained_numeric_constraints_validation: 50 is accepted; 0, 200 and 52 are rejected. It passed before and after, which is expected since validation was never broken; it guards against a regression.test_numeric_constraint_type_mismatch: gt/ge/lt/le/multiple_of with a float bound on an int schema. Thegtcase failed before (1 was accepted); the others guard the fallback path.test_repeated_numeric_constraint: the same constraint chained twice. Five of the six cases failed against the first version of the fix and pass now.
tests/test_validators.py::test_v1_validator_deprecated fails both with and without my changes (checked by stashing them), so it is an unrelated existing failure. I didn't change or skip any existing test.
Requirements
| Item | Status |
|---|---|
ge(1).le(100) schema keeps maximum | Fixed; test passes |
le(100).ge(1) schema keeps minimum | Fixed; test passes |
constrain(Interval(ge=1, le=100)) schema complete | Fixed; test passes |
ge(1).le(100).multiple_of(5) schema complete; validation rejects 200 and 52 | Fixed; schema test and validation test pass |
gt(1).lt(100) and plain Annotated[int, Ge, Le] controls still work | Existing gt(0).lt(100) test and the new lt(100).gt(1) case pass; nothing outside the pipeline changed |
| One symmetric change across all five branches, not three patches | Done |
| Validation still enforces bounds on a type mismatch (the concern #13446 raised) | Kept, and fixed for Gt; covered by test_numeric_constraint_type_mismatch |
Not the falsy-zero Interval issue (#13450) | Out of scope; all tested bounds are non-zero |
The review found no unrelated changes and no scratch files. Len and every other branch are untouched.