Backtestspydanticrun-20261005-183002#13450

Issue #13450 Merged fix PR #13452 Run 5 Oct 2026 · run-20261005-183002 pydantic/pydantic

Experimental pipeline: Interval bounds of zero are silently dropped

Better

Our patch was judged better than the merged fix.

In this judgment, Patch A = our agent, Patch B = the merged fix.

The source changes are byte-for-byte identical. Both replace the four truthiness checks in the `Interval` branch of `_apply_constraint` with `is not None`, which fixes the root cause for all four bounds. Correctness and scope are therefore equal, and the decision rests on tests.

Both patches add cases that would fail before the fix and pass after it.

Patch B strengthens the existing parametrized cases:
- `Interval(ge=0, le=10)` now also rejects `-5`.
- `Interval(gt=0.0, lt=10.0)` now also rejects `0.0` and `-5.0`.
- New int-only cases cover `gt=0`, `le=0` and `lt=0`.
This is tidy, since it fixes the weak existing case (which only checked `11` and so never exercised the zero bound) rather than adding a near-duplicate.

Patch A leaves the weak existing case in place but adds broader zero-bound coverage:
- All four bounds on int, matching every row of the issue's table.
- All four bounds individually on float, with the boundary value itself tested as valid or invalid as appropriate (`0.0` for `ge`/`le`, `0.0` rejected for `gt`/`lt`).
- A `Decimal` case with `ge=Decimal('0')`.
B has no `Decimal` zero-bound case and no float `ge`/`le`/`lt` zero cases in isolation.

B is marginally cleaner because it avoids a semi-duplicate case. However, tests outrank craft, and A's coverage across int, float and Decimal is more thorough. That gives A a small edge.

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

5m 1s

Wall-clock time in the container

Full test suite

No new failures

12,271 passed · 501 skipped · 12,772 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

23vs 15 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

In pydantic/experimental/pipeline.py, _apply_constraint() handles annotated_types.Interval by delegating to the individual comparison constraints, but it tests each bound for truthiness rather than is not None:

elif isinstance(constraint, annotated_types.Interval):
    if constraint.ge:
        s = _apply_constraint(s, annotated_types.Ge(constraint.ge))
    if constraint.gt:
        s = _apply_constraint(s, annotated_types.Gt(constraint.gt))
    if constraint.le:
        s = _apply_constraint(s, annotated_types.Le(constraint.le))
    if constraint.lt:
        s = _apply_constraint(s, annotated_types.Lt(constraint.lt))

Since 0 is falsy, a bound of exactly zero is skipped and the constraint is silently dropped - there is no error, validation simply accepts out-of-range values. Interval(ge=0, le=10) happily accepts -5.

All four bounds are affected. Observed on 2.12.5:

constraintinputexpectedactual
Interval(ge=0, le=10)-5ValidationErroraccepted
Interval(ge=0, le=10)20ValidationErrorValidationError (le=10 works)
Interval(gt=0)-5ValidationErroraccepted
Interval(gt=0)0ValidationErroraccepted
Interval(le=0)5ValidationErroraccepted
Interval(lt=0)5ValidationErroraccepted
Interval(ge=1, le=10)-5ValidationErrorValidationError (control: non-zero bound is fine)

The non-zero control confirms the trigger is specifically the zero bound, not Interval in general. Zero is a very common lower bound, so this silently weakens validation in ordinary usage.

The fix looks like changing the four checks to if constraint.ge is not None: (and likewise for gt/le/lt).

This is related to, but distinct from, #13446 - that one is about Gt being dropped on a numeric type mismatch, whereas this is the Interval branch dropping zero bounds regardless of type.

Happy to open a PR if that would help.

Example Code

from typing import Annotated

import annotated_types
from pydantic import TypeAdapter
from pydantic.experimental.pipeline import validate_as

ta = TypeAdapter(Annotated[int, validate_as(int).constrain(annotated_types.Interval(ge=0, le=10))])

print(ta.validate_python(-5))  # -> -5   (expected: ValidationError, ge=0 is violated)
ta.validate_python(20)         # -> ValidationError (le=10 is enforced correctly)

# A non-zero lower bound behaves correctly:
ta2 = TypeAdapter(Annotated[int, validate_as(int).constrain(annotated_types.Interval(ge=1, le=10))])
ta2.validate_python(-5)        # -> ValidationError (correct)

Python, Pydantic & OS Version

             pydantic version: 2.12.5
        pydantic-core version: 2.41.5
          pydantic-core build: profile=release pgo=false
               python version: 3.14.3 (tags/v3.14.3:323c59a, Feb  3 2026, 16:04:56) [MSC v.1944 64 bit (AMD64)]
                     platform: Windows-11-10.0.26200-SP0
             related packages: fastapi-0.136.3 mypy-2.2.0 pydantic-settings-2.14.0 typing_extensions-4.15.0
                       commit: unknown

The two patches

Our patch+19 −4
pydantic/experimental/pipeline.pyindex 9b886db8..b9668517 100644@@ -613,13 +613,13 @@ def _apply_constraint(  # noqa: C901         else:             raise NotImplementedError('Constraining to a specific timezone is not yet supported')     elif isinstance(constraint, annotated_types.Interval):-        if constraint.ge:+        if constraint.ge is not None:             s = _apply_constraint(s, annotated_types.Ge(constraint.ge))-        if constraint.gt:+        if constraint.gt is not None:             s = _apply_constraint(s, annotated_types.Gt(constraint.gt))-        if constraint.le:+        if constraint.le is not None:             s = _apply_constraint(s, annotated_types.Le(constraint.le))-        if constraint.lt:+        if constraint.lt is not None:             s = _apply_constraint(s, annotated_types.Lt(constraint.lt))         assert s is not None     elif isinstance(constraint, annotated_types.Predicate):tests/test_pipeline.pyindex a71fb6b1..340295ed 100644@@ -91,6 +91,21 @@ def test_parse_multipleOf(type_: Any, pipeline: Any, valid_cases: list[Any], inv         ),         (int, validate_as(int).constrain(Interval(gt=1, lt=5)), [2, 4], [1, 5]),         (float, validate_as(float).constrain(Interval(ge=1.0, le=5.0)), [1.0, 3.0, 5.0], [0.9, 5.1]),+        # Zero bounds must not be dropped:+        (int, validate_as(int).constrain(Interval(ge=0, le=10)), [0, 10], [-5, 20]),+        (int, validate_as(int).constrain(Interval(gt=0)), [1], [0, -5]),+        (int, validate_as(int).constrain(Interval(le=0)), [0, -5], [5]),+        (int, validate_as(int).constrain(Interval(lt=0)), [-1], [0, 5]),+        (float, validate_as(float).constrain(Interval(ge=0.0)), [0.0, 1.5], [-0.1]),+        (float, validate_as(float).constrain(Interval(gt=0.0)), [0.1], [0.0, -1.0]),+        (float, validate_as(float).constrain(Interval(le=0.0)), [0.0, -1.0], [0.1]),+        (float, validate_as(float).constrain(Interval(lt=0.0)), [-0.1], [0.0, 1.0]),+        (+            Decimal,+            validate_as(Decimal).constrain(Interval(ge=Decimal('0'), lt=Decimal('0.5'))),+            [Decimal('0'), Decimal('0.4')],+            [Decimal('-0.1'), Decimal('0.5')],+        ),     ], ) def test_interval_constraints(type_: Any, pipeline: Any, valid_cases: list[Any], invalid_cases: list[Any]) -> None: 
Merged fix · PR #13452+9 −6
pydantic/experimental/pipeline.pyindex 9b886db88..b96685172 100644@@ -613,13 +613,13 @@ def _apply_constraint(  # noqa: C901         else:             raise NotImplementedError('Constraining to a specific timezone is not yet supported')     elif isinstance(constraint, annotated_types.Interval):-        if constraint.ge:+        if constraint.ge is not None:             s = _apply_constraint(s, annotated_types.Ge(constraint.ge))-        if constraint.gt:+        if constraint.gt is not None:             s = _apply_constraint(s, annotated_types.Gt(constraint.gt))-        if constraint.le:+        if constraint.le is not None:             s = _apply_constraint(s, annotated_types.Le(constraint.le))-        if constraint.lt:+        if constraint.lt is not None:             s = _apply_constraint(s, annotated_types.Lt(constraint.lt))         assert s is not None     elif isinstance(constraint, annotated_types.Predicate):tests/test_pipeline.pyindex a71fb6b14..00e421012 100644@@ -81,8 +81,11 @@ def test_parse_multipleOf(type_: Any, pipeline: Any, valid_cases: list[Any], inv @pytest.mark.parametrize(     'type_, pipeline, valid_cases, invalid_cases',     [-        (int, validate_as(int).constrain(Interval(ge=0, le=10)), [0, 5, 10], [11]),-        (float, validate_as(float).constrain(Interval(gt=0.0, lt=10.0)), [0.1, 9.9], [10.0]),+        (int, validate_as(int).constrain(Interval(ge=0, le=10)), [0, 5, 10], [-5, 11]),+        (float, validate_as(float).constrain(Interval(gt=0.0, lt=10.0)), [0.1, 9.9], [0.0, -5.0, 10.0]),+        (int, validate_as(int).constrain(Interval(gt=0)), [1, 100], [0, -5]),+        (int, validate_as(int).constrain(Interval(le=0)), [0, -5], [1]),+        (int, validate_as(int).constrain(Interval(lt=0)), [-5], [0, 1]),         (             Decimal,             validate_as(Decimal).constrain(Interval(ge=Decimal('1.0'), lt=Decimal('10.0'))),