Backtestspydanticrun-20261002-175417#13450

Issue #13450 Merged fix PR #13452 Run 2 Oct 2026 · run-20261002-175417 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 two source fixes are byte-identical. Each replaces the four truthiness checks in the `Interval` branch of `_apply_constraint` with `is not None`, which fixes the root cause the issue identifies for all of `ge`, `gt`, `le` and `lt`. Correctness is therefore equal.

The difference is in the tests. Both patches add cases that fail before the fix and pass after it.

Patch B extends the existing `test_interval_constraints` parametrization. It adds `-5` to the `ge=0` case and `0.0`/`-5.0` to the float `gt=0.0` case, plus new int cases for `gt=0`, `le=0` and `lt=0`. This tidily fixes the original test's blind spot, and it adds no duplicated test body.

Patch A adds a dedicated `test_interval_constraints_zero_bounds` test. It covers the zero bound for all four operators on both int and float, and adds a Decimal case with `ge=Decimal('0')`. That checks the fix holds across numeric types, including a zero Decimal, which is also falsy. It also checks values on both sides of the boundary, such as `0` versus `-1` and `11`.

Patch A's test body duplicates the existing test function, which is a small craft cost. Tests rank above craft, so Patch A's broader and more systematic coverage of the exact failure mode gives it a narrow 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

8m 38s

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

38vs 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+34 −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..7498d2da 100644@@ -102,6 +102,36 @@ def test_interval_constraints(type_: Any, pipeline: Any, valid_cases: list[Any],             ta.validate_python(y)  +@pytest.mark.parametrize(+    'type_, pipeline, valid_cases, invalid_cases',+    [+        (int, validate_as(int).constrain(Interval(ge=0, le=10)), [0, 5, 10], [-5, -1, 11, 20]),+        (int, validate_as(int).constrain(Interval(gt=0)), [1, 5], [0, -5]),+        (int, validate_as(int).constrain(Interval(le=0)), [0, -5], [1, 5]),+        (int, validate_as(int).constrain(Interval(lt=0)), [-1, -5], [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, -0.1]),+        (float, validate_as(float).constrain(Interval(le=0.0)), [0.0, -1.5], [0.1]),+        (float, validate_as(float).constrain(Interval(lt=0.0)), [-0.1], [0.0, 0.1]),+        (+            Decimal,+            validate_as(Decimal).constrain(Interval(ge=Decimal('0'), lt=Decimal('10'))),+            [Decimal('0'), Decimal('9.9')],+            [Decimal('-0.1'), Decimal('10')],+        ),+    ],+)+def test_interval_constraints_zero_bounds(+    type_: Any, pipeline: Any, valid_cases: list[Any], invalid_cases: list[Any]+) -> None:+    ta = TypeAdapter[Any](Annotated[type_, pipeline])+    for x in valid_cases:+        assert ta.validate_python(x) == x+    for y in invalid_cases:+        with pytest.raises(ValueError):+            ta.validate_python(y)++ @pytest.mark.parametrize(     'type_, pipeline, valid_cases, invalid_cases',     [ 
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'))),