Backtestspydanticrun-20260923-170312#13450

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

Experimental pipeline: Interval bounds of zero are silently dropped

Worse

The merged fix was judged better than our patch.

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

The source fix is byte-for-byte identical in both patches (truthiness → `is not None`), so the decision rests entirely on tests. Both add regression coverage for zero bounds across all four constraints (ge/gt/le/lt) with cases that fail before the fix and pass after. The difference is craft: Patch A leaves the pre-existing weak row `Interval(ge=0, le=10)` with invalid_cases `[11]` untouched — a row that never exercised the bug — and then appends a near-duplicate row `Interval(ge=0, le=10)` with `[-5, 11]`, introducing redundancy. Patch B instead repairs the existing rows in place: it strengthens `Interval(ge=0, le=10)` to `[-5, 11]` and the float `Interval(gt=0.0, lt=10.0)` to reject `0.0`/`-5.0`, then adds targeted gt/le/lt zero rows. Patch B thus fixes the root cause of the weak coverage (existing rows that couldn't catch the regression) rather than layering a duplicate on top, giving cleaner, non-redundant tests with equivalent bound coverage. Both are correct and minimal in the source change; B edges out on test quality and avoids the redundant row, so it is the better fix.

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

3m 40s7 turns

Wall-clock time in the container

Full test suite

No new failures

6,420 passed · 368 skipped · 6,788 total

Contamination audit

Unknown

See the audit notes for this run

Patch size

12vs 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+8 −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..1dade356 100644@@ -91,6 +91,10 @@ 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]),+        (int, validate_as(int).constrain(Interval(ge=0, le=10)), [0, 5, 10], [-5, 11]),+        (int, validate_as(int).constrain(Interval(gt=0)), [1, 5], [-5, 0]),+        (int, validate_as(int).constrain(Interval(le=0)), [0, -5], [5]),+        (int, validate_as(int).constrain(Interval(lt=0)), [-5], [5, 0]),     ], ) def test_interval_constraints(type_: Any, pipeline: Any, valid_cases: list[Any], invalid_cases: list[Any]) -> None: 
Merged fix · PR #+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'))), 

What the agent reported

Only the two expected files changed. Done.

Summary

What was wrong: In pydantic/experimental/pipeline.py, the _apply_constraint() function's annotated_types.Interval branch tested each bound for truthiness (if constraint.ge:) instead of is not None. Because 0 is falsy, a bound of exactly zero was silently dropped — so Interval(ge=0, le=10) accepted -5, Interval(gt=0) accepted -5/0, etc. All four bounds (ge/gt/le/lt) were affected.

What I changed:

  • pydantic/experimental/pipeline.py (lines 616–622): changed all four if constraint.<bound>: checks to if constraint.<bound> is not None:. Smallest possible fix; nothing else touched.
  • tests/test_pipeline.py: added four rows to the existing test_interval_constraints parametrize list exercising zero bounds — Interval(ge=0, le=10) rejecting -5, Interval(gt=0) rejecting -5/0, Interval(le=0) rejecting 5, Interval(lt=0) rejecting 5/0. Existing rows untouched.

Test evidence:

  • Before the fix: ./bt-test tests/test_pipeline.py::test_interval_constraints → 4 failed, 5 passed (all four new zero-bound rows failed with "DID NOT RAISE ValueError").
  • After the fix: ./bt-test tests/test_pipeline.py → 70 passed.
  • git diff --stat confirms only the two expected files changed.

Requirements checklist:

  • Fix the Interval branch to use is not None for ge/gt/le/lt — implemented, verified by review and passing tests.
  • Cover all four bounds affected by the zero-bound bug — implemented with regression rows for ge=0, gt=0, le=0, lt=0, each asserting the user-visible ValidationError outcome (confirmed failing before, passing after).
  • The report's related-but-distinct issue #13446 (Gt dropped on numeric type mismatch) — out of scope by the report's own statement; not touched. Evidence: the diff (git diff --stat) shows only the Interval truthiness change in pipeline.py, no changes to the standalone Gt/type-mismatch handling.

The reporter offered to open a PR — no action needed here since the fix is applied in the working tree as uncommitted edits.