Backtestspydanticrun-20260923-170312#13507

Issue #13507 Merged fix PR # Run 23 Sep 2026 · run-20260923-170312 pydantic/pydantic

Experimental pipeline: every constraint chained after ge/lt/le is dropped from the JSON schema

Better

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 root cause (the fallback `_check_func` being applied unconditionally after the native core-schema field is set) and both include the same key regression tests proving the JSON schema now carries every chained bound (ge.le, le.ge, constrain(Interval), ge.le.multiple_of). The decision turns on scope and correctness risk. Patch B is the minimal, targeted fix: it introduces a `native_constraint_applied` flag and only falls back to the function check when the native field was NOT set — exactly the shape the issue author endorses (from #13473) and applies it symmetrically across all five branches (Gt/Ge/Lt/Le/MultipleOf), which the issue explicitly calls for. It preserves every existing behavior, including routing genuine type mismatches (e.g. `.ge(0.0)` on an int schema, a `Decimal` bound on a float schema) to the function check as before. Patch A goes further than the issue requires: it deletes the per-type `isinstance` guards entirely and assigns `s['gt'] = gt` directly, relying on an unstated assumption that 'pydantic-core does the casting.' That is a behavioral change beyond the reported schema bug — a mismatched-type bound (e.g. a float `0.0` written into an int core schema) is now emitted as a native constraint, which can leak into validation and produce a float-valued `minimum` in the published JSON schema rather than the previous, deliberate function-check fallback. Patch A does add more validation test cases covering those mismatch/transform scenarios, but that thoroughness is partly documenting the very scope expansion that makes it riskier, and the test evidence does not confirm they pass. Weighing correctness (B avoids the pydantic-core casting assumption and preserves the guard semantics), scope (B is as small as a correct fix allows; A is a refactor that removes guards), and consistency with the in-flight convention, Patch B is the better fix. Patch A's extra schema/validation tests are a genuine plus but do not outweigh its broader, riskier change.

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 54s12 turns

Wall-clock time in the container

Full test suite

No new failures

6,432 passed · 368 skipped · 6,800 total

Contamination audit

Unknown

See the audit notes for this run

Patch size

75vs 112 merged

Changed lines, ours vs merged

Initial 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).

expressionJSON schemavalidation
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_applied flag to MultipleOf to avoid a float parity problem. Same shape as the fix needed here.
  • #13446 restructures Gt so 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

Our patch+62 −13
pydantic/experimental/pipeline.pyindex b9668517..ab0874eb 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+        native_constraint_applied = False         if s and s['type'] in {'int', 'float', 'decimal'}:             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+        native_constraint_applied = False         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 = 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+        native_constraint_applied = False         if s and s['type'] in {'int', 'float', 'decimal'}:             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+        native_constraint_applied = False         if s and s['type'] in {'int', 'float', 'decimal'}:             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+        native_constraint_applied = False         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+                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..2a036451 100644@@ -338,6 +338,26 @@ 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).gt(0) | validate_as(int).lt(100)],             {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]}, 
Merged fix · PR #+69 −43
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

Only the two expected files changed. The fix is complete and verified.

Summary

What was wrong. In pydantic/experimental/pipeline.py, _apply_constraint() applied a fallback _check_func after-validator unconditionally in the Ge, Lt, Le, and MultipleOf branches — even when the native core-schema field (e.g. s['ge'] = ge) had just been set. That wrapped the schema in a function-after type, so the next chained constraint saw s['type'] == 'function-after' (not in {'int','float','decimal'}) and could not attach its own native bound. The constraint survived only inside an opaque callable invisible to JSON-schema generation. Result: .ge(1).le(100) published {'minimum': 1} with no maximum, while validation stayed correct. Gt avoided the schema bug only by nesting its fallback in an else, but that idiom is itself subtly wrong (it silently drops the check when the schema type matches but the bound's value type doesn't).

What I changed. Applied the native_constraint_applied flag pattern (the shape from #13473) symmetrically across all five numeric branches — Gt, Ge, Lt, Le, MultipleOf. The flag is set True only where a native field is actually assigned, and the _check_func fallback runs only when the flag is False. This preserves the raw int/float/decimal schema type so subsequent chained constraints attach their bounds natively, and it fixes Gt's latent validation gap on type-mismatched bounds. Len, Timezone, and all other branches are untouched. No test files were modified by the implementer.

Test evidence.

  • Added 4 regression cases to test_json_schema in tests/test_pipeline.py. Confirmed they fail before the fix (4 failed, 9 passed — schemas missing the second bound) and pass after.
  • Full gate: ./bt-test tests/test_pipeline.py → 73 passed (all pre-existing tests still green, including the .gt(0).lt(100) and Interval controls).
  • git diff --stat: only pydantic/experimental/pipeline.py and tests/test_pipeline.py changed. No scratch/temp files. Changes left uncommitted.

Requirements checklist.

  1. .ge(1).le(100) publishes both minimum and maximum — implemented, regression test passes.
  2. .le(100).ge(1) (reversed order) publishes both bounds — implemented, regression test passes.
  3. .constrain(Interval(ge=1, le=100)) publishes both bounds — implemented, regression test passes.
  4. .ge(1).le(100).multiple_of(5) publishes minimum, maximum, and multipleOf — implemented, regression test passes.
  5. Validation stays correct (0 reject / 50 accept / 200 reject) — preserved; test_interval_constraints and the ge/le/gt/lt validation tests pass unchanged.
  6. One symmetric change across all five branches rather than three separate patches — implemented; the flag pattern is applied to Gt, Ge, Lt, Le, MultipleOf. Reviewer confirmed symmetry and flag correctness.
  7. Controls must not regress (.gt(1).lt(100), Annotated[int, Ge(1), Le(100)]) — verified; existing schema tests pass.
  8. Offer to "fold into an existing PR (#13446/#13473)" — skipped (out of scope for a working-tree fix; those PRs are external). The change is deliberately shaped to match #13473's idiom so it can be folded in if desired.