Backtestspydanticrun-20260929-204949#13450

Issue #13450 Merged fix PR #13452 Run 29 Sep 2026 · run-20260929-204949 pydantic/pydantic

Experimental pipeline: Interval bounds of zero are silently dropped

Par

Our patch was judged on par with the merged fix.

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

The source fix is byte-for-byte identical in both patches: all four Interval bound checks changed from truthiness to `is not None`, which correctly addresses the root cause of zero bounds being dropped. Both would hold up under every scenario in the issue table. The only difference is test placement/coverage, and it is negligible. Patch A augments existing parametrized cases (adding `-5` to `Interval(ge=0, le=10)`, `0.0` to the float `gt`/`lt` case) and adds dedicated `gt=0`/`le=0`/`lt=0` cases, giving both int and float zero-bound coverage. Patch B adds equivalent cases (`ge=0/le=10`, `gt=0`, `le=0`, `lt=0`) to a dedicated `test_interval_constraints` function without deleting anything. Both sets of tests fail before the fix and pass after, and both exercise every affected bound. Patch A's edits touch an existing case (minor extra churn) but add float cross-type coverage; Patch B is slightly cleaner by appending to a purpose-named test. These advantages roughly cancel, leaving no meaningful difference in correctness, scope, or craft.

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 35s8 turns

Wall-clock time in the container

Full test suite

No new failures

12,266 passed · 501 skipped · 12,767 total

Contamination audit

Clean

No sign the agent saw the real fix

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..b2f35bea 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, 20]),+        (int, validate_as(int).constrain(Interval(gt=0)), [1, 5], [0, -5]),+        (int, validate_as(int).constrain(Interval(le=0)), [0, -5], [5]),+        (int, validate_as(int).constrain(Interval(lt=0)), [-1, -5], [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'))), 

What the agent reported

The diff is clean and scoped to exactly the two intended files. Done.

Summary

What was wrong: In pydantic/experimental/pipeline.py, the annotated_types.Interval branch of _apply_constraint() (lines 615-624) tested each bound with a truthiness check (if constraint.ge:) instead of is not None. Because 0 is falsy, a bound of exactly zero was silently dropped and the constraint never applied — so e.g. Interval(ge=0, le=10) wrongly accepted -5. All four bounds (ge/gt/le/lt) were affected.

What I changed:

  • pydantic/experimental/pipeline.py: changed the four if constraint.<ge|gt|le|lt>: checks to if constraint.<...> is not None:. Smallest possible fix; no other production changes.
  • tests/test_pipeline.py: added 4 parametrize rows to the existing test_interval_constraints (no existing tests modified), covering zero bounds for every bound type:
  • Interval(ge=0, le=10) valid [0,5,10] / invalid [-5,20]
  • Interval(gt=0) valid [1,5] / invalid [0,-5]
  • Interval(le=0) valid [0,-5] / invalid [5]
  • Interval(lt=0) valid [-1,-5] / invalid [0,5]

Test evidence:

  • Before the fix: the 4 new cases failed (4 failed, 5 passed) with DID NOT RAISE ValueError — confirming the bug.
  • After the fix: ./bt-test tests/test_pipeline.py → 70 passed, including the 4 regression cases and all previously passing tests.

Requirements disposition:

  • Fix all four zero-bound checks (is not None) — implemented, verified by full test run.
  • Regression test exercising the reported scenario (Interval(ge=0, le=10) rejecting -5, plus gt/le/lt zero bounds) — implemented, seen failing before and passing after.
  • Offer to open a PR (report author's aside) — not an action for this session; left as uncommitted working-tree edits per instructions.
  • Distinction from #13446 (numeric type-mismatch drop of Gt) — out of scope / not touched; the fix is confined to the Interval branch's None-vs-truthiness handling, and the individual Gt/Ge/Le/Lt handler branches are unchanged (confirmed by reviewer).

All changes left uncommitted in the working tree.