Backtestspydanticrun-20260930-144322#13467

Issue #13467 Merged fix PR #13484 Run 30 Sep 2026 · run-20260930-144322 pydantic/pydantic

Support Ellipsis

Better

Our patch was judged better than the merged fix.

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

Patch A gives full, working support for `EllipsisType` in Python code only. Python validation uses an is-instance check. JSON validation accepts the string "..." and converts it to `...`. JSON serialization turns `...` into "...", and non-Ellipsis values raise `PydanticSerializationUnexpectedValue` so union serialization falls through to the other member. It also produces a sensible JSON schema (const '...').

Its tests cover the issue's scenario, `tuple[int | EllipsisType, int | EllipsisType]` in a model, across validate_python, validate_json, model_dump, model_dump(mode='json') and model_dump_json. They also check union ordering, invalid Python and JSON inputs, and the serialization warning. These tests would fail before the change.

Patch B adds a native Rust validator, serializer, error type and core schema. That is heavier and in some ways more idiomatic for core, but it only supports Python mode:
- JSON validation always fails, because `input.as_python()` is None for JSON input.
- JSON serialization raises an error.
- JSON schema generation raises `PydanticInvalidForJsonSchema`.

So `model_dump_json()` and `model_validate_json()` on the issue's model would fail. The serializer's own comment says standalone use "isn't something we explicitly support." Its tests mostly confirm these limitations, and none checks the union/tuple scenario from the issue.

B also adds considerably more surface area (a new core schema type, error type, Rust modules), which is more risk for less functionality. On correctness and completeness for the reported use case, A is clearly better.

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

4m 8s13 turns

Wall-clock time in the container

Full test suite

No new failures

12,316 passed · 499 skipped · 12,815 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

86vs 225 merged

Changed lines, ours vs merged

Initial Checks

  • I have searched Google & GitHub for similar requests and couldn't find anything
  • I have read and followed the docs and still think this feature is missing

Description

Ellipsis is a builtin type that pydantic does not support. Its usage is infrequent, but it can be useful to express placeholders:

This is a bit of a contrived example, but:

class Model(pydantic.BaseModel):
    m: list[list[float]]
    subset: tuple[int | Ellipsis, int | Ellipsis]

    def subset_arr(self) -> np.NDArray:
        return np.asarray(self.m)[*self.subset]

Here's how I implement this right now with an adapter: https://github.com/psalvaggio/scientific_pydantic/blob/main/src/scientific_pydantic/ellipsis.py

However, since this is a standard library type, I think this would be a good thing to live in pydantic itself.

Affected Components

The two patches

Our patch+85 −1
docs/api/standard_library_types.mdindex 4739bdb4..32283a22 100644@@ -756,6 +756,15 @@ Supported types: [`None`][], [`NoneType`][types.NoneType] or `Literal[None]` (th  Allows only `None` as a value. +## Ellipsis++Supported type: [`EllipsisType`][types.EllipsisType].++* In Python mode, allows only the [`Ellipsis`][] (`...`) object as a value.+* In JSON mode, allows only the string `"..."`, which is converted to the [`Ellipsis`][] object.+* Serializes to the string `'...'` in JSON mode.+* JSON Schema: a string constant `'...'`.+ ## Generic collection types  Pydantic supports a wide variety of generic collection types, both built-ins (such as [`list`][]) and abstract base classespydantic/_internal/_generate_schema.pyindex 3fba8dc3..6caa414f 100644@@ -23,7 +23,7 @@ from inspect import Parameter, _ParameterKind from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network from itertools import chain from operator import attrgetter-from types import FunctionType, GenericAlias, LambdaType, MethodType, NoneType+from types import EllipsisType, FunctionType, GenericAlias, LambdaType, MethodType, NoneType from typing import (     TYPE_CHECKING,     Any,@@ -363,6 +363,7 @@ class GenerateSchema:         MultiHostUrl: lambda self, obj: core_schema.multi_host_url_schema(),         None: lambda self, obj: core_schema.none_schema(),         NoneType: lambda self, obj: core_schema.none_schema(),+        EllipsisType: lambda self, obj: self._ellipsis_schema(),         MISSING: lambda self, obj: core_schema.missing_sentinel_schema(),         type: lambda self, obj: self._type_schema(),         dict: lambda self, obj: self._dict_schema(Any, Any),@@ -551,6 +552,24 @@ class GenerateSchema:                 metadata={'pydantic_js_functions': [get_json_schema_no_cases]},             ) +    def _ellipsis_schema(self) -> CoreSchema:+        literal_str_schema = core_schema.literal_schema(['...'])++        def ser_ellipsis(value: Any) -> str:+            if value is not ...:+                raise PydanticSerializationUnexpectedValue(+                    f"Expected `{EllipsisType}` but got `{type(value)}` with value `'{value}'` - serialized value may not be as expected."+                )+            return '...'++        return core_schema.json_or_python_schema(+            json_schema=core_schema.no_info_after_validator_function(lambda _: ..., literal_str_schema),+            python_schema=core_schema.is_instance_schema(EllipsisType),+            serialization=core_schema.plain_serializer_function_ser_schema(+                ser_ellipsis, when_used='json', return_schema=literal_str_schema+            ),+        )+     def _ip_schema(self, tp: Any) -> CoreSchema:         from ._validators import IP_VALIDATOR_LOOKUP, IpType tests/test_types.pyindex df4d5f06..a0232dd1 100644@@ -20,6 +20,7 @@ from enum import Enum, IntEnum from numbers import Number from pathlib import Path from re import Pattern+from types import EllipsisType from typing import (     Annotated,     Any,@@ -5413,6 +5414,61 @@ def test_none_literal():     ]  +def test_ellipsis_type() -> None:+    ta = TypeAdapter(EllipsisType)++    assert ta.validate_python(...) is ...+    assert ta.validate_json('"..."') is ...++    assert ta.dump_python(...) is ...+    assert ta.dump_python(..., mode='json') == '...'+    assert ta.dump_json(...) == b'"..."'++    assert ta.json_schema() == {'const': '...', 'type': 'string'}+++@pytest.mark.parametrize('value', [1, '...', None, EllipsisType])+def test_ellipsis_type_invalid_python(value: Any) -> None:+    with pytest.raises(ValidationError):+        TypeAdapter(EllipsisType).validate_python(value)+++@pytest.mark.parametrize('value', ['1', '"."', '"...."', 'null', '[]'])+def test_ellipsis_type_invalid_json(value: str) -> None:+    with pytest.raises(ValidationError):+        TypeAdapter(EllipsisType).validate_json(value)+++def test_ellipsis_type_in_model_union_tuple() -> None:+    class Model(BaseModel):+        subset: tuple[int | EllipsisType, int | EllipsisType]++    assert Model(subset=(1, ...)).subset == (1, ...)+    assert Model(subset=(..., 2)).subset == (..., 2)+    assert Model.model_validate_json('{"subset": [1, "..."]}').subset == (1, ...)++    m = Model(subset=(1, ...))+    assert m.model_dump() == {'subset': (1, ...)}+    assert m.model_dump(mode='json') == {'subset': [1, '...']}+    assert m.model_dump_json() == '{"subset":[1,"..."]}'++    with pytest.raises(ValidationError):+        Model(subset=(1, '...'))+++def test_ellipsis_type_union_first_serialization() -> None:+    class Model(BaseModel):+        v: tuple[EllipsisType | int, EllipsisType | int]++    m = Model(v=(1, ...))+    assert m.model_dump(mode='json') == {'v': [1, '...']}+    assert m.model_dump_json() == '{"v":[1,"..."]}'+    assert Model(v=(..., 2)).model_dump_json() == '{"v":["...",2]}'++    with pytest.warns(UserWarning, match='PydanticSerializationUnexpectedValue'):+        TypeAdapter(EllipsisType).dump_json(1)++ def test_default_union_types():     class DefaultModel(BaseModel):         v: int | bool | str 
Merged fix · PR #13484+224 −1
docs/errors/validation_errors.mdindex b0d509b97..fc0539fef 100644@@ -724,6 +724,27 @@ except ValidationError as exc:     #> 'dict_type' ``` +## `ellipsis_error`++This error is raised when the input isn't the [`Ellipsis`][] literal:++```python+from types import EllipsisType++from pydantic import BaseModel, ValidationError+++class Model(BaseModel):+    e: EllipsisType+++try:+    Model(e=1)+except ValidationError as exc:+    print(repr(exc.errors()[0]['type']))+    #> 'ellipsis_error'+```+ ## `enum`  This error is raised when the input value does not exist in an `enum` field members:pydantic-core/python/pydantic_core/core_schema.pyindex c6118a082..965cf28e1 100644@@ -1453,6 +1453,25 @@ def missing_sentinel_schema(     )  +class EllipsisSchema(TypedDict, total=False):+    type: Required[Literal['ellipsis']]+    metadata: dict[str, Any]+    serialization: SerSchema+++def ellipsis_schema(+    metadata: dict[str, Any] | None = None,+    serialization: SerSchema | None = None,+) -> EllipsisSchema:+    """Returns a schema for the [`Ellipsis`][] literal."""++    return _dict_not_none(+        type='ellipsis',+        metadata=metadata,+        serialization=serialization,+    )++ # must match input/parse_json.rs::JsonType::try_from JsonType = Literal['null', 'bool', 'int', 'float', 'str', 'list', 'dict'] @@ -4201,6 +4220,7 @@ if not MYPY:         | TimedeltaSchema         | LiteralSchema         | MissingSentinelSchema+        | EllipsisSchema         | EnumSchema         | IsInstanceSchema         | IsSubclassSchema@@ -4261,6 +4281,7 @@ CoreSchemaType: TypeAlias = Literal[     'timedelta',     'literal',     'missing-sentinel',+    'ellipsis',     'enum',     'is-instance',     'is-subclass',@@ -4363,6 +4384,7 @@ ErrorType: TypeAlias = Literal[     'assertion_error',     'literal_error',     'missing_sentinel_error',+    'ellipsis_error',     'date_type',     'date_parsing',     'date_from_datetime_parsing',pydantic-core/src/errors/types.rsindex da9cdae0c..8f8e936ce 100644@@ -324,6 +324,9 @@ error_types! {     // ---------------------     // missing sentinel     MissingSentinelError {},+    // ---------------------+    // ellipsis+    EllipsisError {},     // date errors     DateType {},     DateParsing {@@ -552,6 +555,7 @@ impl ErrorType {             Self::CustomError { .. } => "", // custom errors are handled separately             Self::LiteralError { .. } => "Input should be {expected}",             Self::MissingSentinelError { .. } => "Input should be the 'MISSING' sentinel",+            Self::EllipsisError { .. } => "Input should be the 'Ellipsis' literal",             Self::DateType { .. } => "Input should be a valid date",             Self::DateParsing { .. } => "Input should be a valid date in the format YYYY-MM-DD, {error}",             Self::DateFromDatetimeParsing { .. } => "Input should be a valid date or datetime, {error}",pydantic-core/src/serializers/shared.rsindex 5f7efee37..f6342c1ec 100644@@ -153,6 +153,7 @@ combined_serializer! {         TaggedUnion: super::type_serializers::union::TaggedUnionSerializer;         Literal: super::type_serializers::literal::LiteralSerializer;         MissingSentinel: super::type_serializers::missing_sentinel::MissingSentinelSerializer;+        Ellipsis: super::type_serializers::ellipsis::EllipsisSerializer;         Enum: super::type_serializers::enum_::EnumSerializer;         Recursive: super::type_serializers::definitions::DefinitionRefSerializer;         Tuple: super::type_serializers::tuple::TupleSerializer;@@ -385,6 +386,7 @@ impl PyGcTraverse for CombinedSerializer {             CombinedSerializer::TaggedUnion(inner) => inner.py_gc_traverse(visit),             CombinedSerializer::Literal(inner) => inner.py_gc_traverse(visit),             CombinedSerializer::MissingSentinel(inner) => inner.py_gc_traverse(visit),+            CombinedSerializer::Ellipsis(inner) => inner.py_gc_traverse(visit),             CombinedSerializer::Enum(inner) => inner.py_gc_traverse(visit),             CombinedSerializer::Recursive(inner) => inner.py_gc_traverse(visit),             CombinedSerializer::Tuple(inner) => inner.py_gc_traverse(visit),pydantic-core/src/serializers/type_serializers/ellipsis.rsnew file mode 100644index 000000000..634916c5d@@ -0,0 +1,74 @@+// This serializer is defined so that building a schema serializer containing an+// 'ellipsis' core schema doesn't crash. In practice, the serializer can be used+// if the 'ellipsis' core schema is used standalone (e.g. with a Pydantic type+// adapter), but this isn't something we explicitly support.++use std::borrow::Cow;+use std::sync::{Arc, LazyLock};++use pyo3::prelude::*;+use pyo3::types::{PyDict, PyEllipsis};++use serde::ser::Error;++use crate::PydanticSerializationUnexpectedValue;+use crate::definitions::DefinitionsBuilder;+use crate::serializers::SerializationState;++use super::{BuildSerializer, CombinedSerializer, TypeSerializer};++#[derive(Debug)]+pub struct EllipsisSerializer {}++static ELLIPSIS_SERIALIZER: LazyLock<Arc<CombinedSerializer>> =+    LazyLock::new(|| Arc::new(EllipsisSerializer {}.into()));++impl BuildSerializer for EllipsisSerializer {+    const EXPECTED_TYPE: &'static str = "ellipsis";++    fn build(+        _schema: &Bound<'_, PyDict>,+        _config: Option<&Bound<'_, PyDict>>,+        _definitions: &mut DefinitionsBuilder<Arc<CombinedSerializer>>,+    ) -> PyResult<Arc<CombinedSerializer>> {+        Ok(ELLIPSIS_SERIALIZER.clone())+    }+}++impl_py_gc_traverse!(EllipsisSerializer {});++impl TypeSerializer for EllipsisSerializer {+    fn to_python(&self, value: &Bound<'_, PyAny>, _state: &mut SerializationState<'_>) -> PyResult<Py<PyAny>> {+        let ellipsis = PyEllipsis::get(value.py());++        if value.is(ellipsis) {+            Ok(ellipsis.to_owned().into_any().unbind())+        } else {+            Err(+                PydanticSerializationUnexpectedValue::new_from_msg(Some("Expected 'Ellipsis' object".to_string()))+                    .to_py_err(),+            )+        }+    }++    fn json_key<'a, 'py>(+        &self,+        key: &'a Bound<'py, PyAny>,+        state: &mut SerializationState<'py>,+    ) -> PyResult<Cow<'a, str>> {+        self.invalid_as_json_key(key, state, Self::EXPECTED_TYPE)+    }++    fn serde_serialize<S: serde::ser::Serializer>(+        &self,+        _value: &Bound<'_, PyAny>,+        _serializer: S,+        _state: &mut SerializationState<'_>,+    ) -> Result<S::Ok, S::Error> {+        Err(Error::custom("'Ellipsis' can't be serialized to JSON".to_string()))+    }++    fn get_name(&self) -> &str {+        Self::EXPECTED_TYPE+    }+}pydantic-core/src/serializers/type_serializers/mod.rsindex da95113ea..ad664e8f8 100644@@ -6,6 +6,7 @@ pub mod datetime_etc; pub mod decimal; pub mod definitions; pub mod dict;+pub mod ellipsis; pub mod enum_; pub mod float; pub mod format;pydantic-core/src/validators/ellipsis.rsnew file mode 100644index 000000000..d3dfa9faf@@ -0,0 +1,48 @@+use core::fmt::Debug;+use std::sync::{Arc, LazyLock};++use pyo3::prelude::*;+use pyo3::types::{PyDict, PyEllipsis};++use crate::errors::{ErrorType, ValError, ValResult};+use crate::input::Input;++use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};++#[derive(Debug, Clone)]+pub struct EllipsisValidator {}++static ELLIPSIS_VALIDATOR: LazyLock<Arc<CombinedValidator>> =+    LazyLock::new(|| CombinedValidator::Ellipsis(EllipsisValidator {}).into());++impl BuildValidator for EllipsisValidator {+    const EXPECTED_TYPE: &'static str = "ellipsis";++    fn build(+        _schema: &Bound<'_, PyDict>,+        _config: Option<&Bound<'_, PyDict>>,+        _definitions: &mut DefinitionsBuilder<Arc<CombinedValidator>>,+    ) -> PyResult<Arc<CombinedValidator>> {+        Ok(ELLIPSIS_VALIDATOR.clone())+    }+}++impl_py_gc_traverse!(EllipsisValidator {});++impl Validator for EllipsisValidator {+    fn validate<'py>(+        &self,+        py: Python<'py>,+        input: &(impl Input<'py> + ?Sized),+        _state: &mut ValidationState<'_, 'py>,+    ) -> ValResult<Py<PyAny>> {+        match input.as_python() {+            Some(v) if v.is(PyEllipsis::get(py)) => Ok(v.to_owned().into()),+            _ => Err(ValError::new(ErrorType::EllipsisError { context: None }, input)),+        }+    }++    fn get_name(&self) -> &str {+        Self::EXPECTED_TYPE+    }+}pydantic-core/src/validators/mod.rsindex 2ab41e6b0..7a6875e3d 100644@@ -37,6 +37,7 @@ mod datetime; pub(crate) mod decimal; mod definitions; mod dict;+mod ellipsis; mod enum_; mod float; pub(crate) mod fraction;@@ -610,6 +611,8 @@ fn build_validator_inner(         literal::LiteralValidator,         // missing sentinel         missing_sentinel::MissingSentinelValidator,+        // ellipsis+        ellipsis::EllipsisValidator,         // enums         enum_::BuildEnumValidator,         // any@@ -775,6 +778,8 @@ pub enum CombinedValidator {     Literal(literal::LiteralValidator),     // Missing sentinel     MissingSentinel(missing_sentinel::MissingSentinelValidator),+    // Ellipsis+    Ellipsis(ellipsis::EllipsisValidator),     // enums     IntEnum(enum_::EnumValidator<enum_::IntEnumValidator>),     StrEnum(enum_::EnumValidator<enum_::StrEnumValidator>),pydantic-core/tests/test_errors.pyindex 274ecb3f6..334e281bd 100644@@ -347,6 +347,7 @@ all_errors = [     ('literal_error', 'Input should be foo', {'expected': 'foo'}),     ('literal_error', 'Input should be foo or bar', {'expected': 'foo or bar'}),     ('missing_sentinel_error', "Input should be the 'MISSING' sentinel", None),+    ('ellipsis_error', "Input should be the 'Ellipsis' literal", None),     ('date_type', 'Input should be a valid date', None),     ('date_parsing', 'Input should be a valid date in the format YYYY-MM-DD, foobar', {'error': 'foobar'}),     ('date_from_datetime_parsing', 'Input should be a valid date or datetime, foobar', {'error': 'foobar'}),pydantic-core/tests/test_schema_functions.pyindex 299b08e3f..65a015a6f 100644@@ -83,6 +83,7 @@ all_schema_functions = [     ),     (core_schema.literal_schema, args(['a', 'b']), {'type': 'literal', 'expected': ['a', 'b']}),     (core_schema.missing_sentinel_schema, args(), {'type': 'missing-sentinel'}),+    (core_schema.ellipsis_schema, args(), {'type': 'ellipsis'}),     (         core_schema.enum_schema,         args(MyEnum, list(MyEnum.__members__.values())),pydantic/_internal/_generate_schema.pyindex 3fba8dc3e..3436338cc 100644@@ -23,7 +23,7 @@ from inspect import Parameter, _ParameterKind from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network from itertools import chain from operator import attrgetter-from types import FunctionType, GenericAlias, LambdaType, MethodType, NoneType+from types import EllipsisType, FunctionType, GenericAlias, LambdaType, MethodType, NoneType from typing import (     TYPE_CHECKING,     Any,@@ -364,6 +364,7 @@ class GenerateSchema:         None: lambda self, obj: core_schema.none_schema(),         NoneType: lambda self, obj: core_schema.none_schema(),         MISSING: lambda self, obj: core_schema.missing_sentinel_schema(),+        EllipsisType: lambda self, obj: core_schema.ellipsis_schema(),         type: lambda self, obj: self._type_schema(),         dict: lambda self, obj: self._dict_schema(Any, Any),         tuple: lambda self, obj: self._tuple_schema(obj),pydantic/json_schema.pyindex 27756c099..c6adb6947 100644@@ -907,6 +907,19 @@ class GenerateJsonSchema:         """         raise PydanticOmit +    def ellipsis_schema(self, schema: core_schema.EllipsisSchema) -> JsonSchemaValue:+        """Handles JSON schema generation for a core schema that checks if a value is the [`Ellipsis`][] literal.++        Unless overridden in a subclass, this raises an error.++        Args:+            schema: The core schema.++        Returns:+            The generated JSON schema.+        """+        return self.handle_invalid_for_json_schema(schema, 'core_schema.EllipsisSchema')+     def enum_schema(self, schema: core_schema.EnumSchema) -> JsonSchemaValue:         """Generates a JSON schema that matches an Enum value. tests/test_json_schema.pyindex 2486dfdd8..633abea77 100644@@ -12,6 +12,7 @@ from enum import Enum, IntEnum from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network from pathlib import Path from re import Pattern+from types import EllipsisType from typing import (     Annotated,     Any,@@ -1319,6 +1320,14 @@ def test_callable_type(type_, default_value, base_json_schema, properties):     assert model_schema['properties'] == properties  +def test_ellipsis_schema() -> None:+    class Model(BaseModel):+        e: EllipsisType++    with pytest.raises(PydanticInvalidForJsonSchema):+        Model.model_json_schema()++ @pytest.mark.parametrize(     'default_value,properties',     (tests/types/test_ellipsis.pynew file mode 100644index 000000000..11b7fdea7@@ -0,0 +1,21 @@+from types import EllipsisType++import pytest+from pydantic_core import PydanticSerializationError, PydanticSerializationUnexpectedValue++from pydantic import TypeAdapter+++def test_ellipsis_literal() -> None:+    ta = TypeAdapter(EllipsisType)++    assert ta.validate_python(...) is ...+    assert ta.dump_python(...) is ...++    with pytest.raises(PydanticSerializationUnexpectedValue):+        ta.dump_python(1)++    with pytest.raises(+        PydanticSerializationError, match="Error serializing to JSON: 'Ellipsis' can't be serialized to JSON"+    ):+        ta.dump_json(...) 

What the agent reported

I added support for types.EllipsisType as a field type. All 12 new tests pass, and the wider test run shows no regressions.

What was wrong: pydantic had no schema handler for EllipsisType (the type of ...). Using it as a field type raised PydanticSerializationError-style schema errors — specifically PydanticSchemaGenerationError: Unable to generate pydantic-core schema for <class 'ellipsis'>. I confirmed this by running the new tests before the fix: all 11 failed with that error.

What I changed:

  • pydantic/_internal/_generate_schema.py: added an EllipsisType entry next to NoneType in the table of built-in types, plus a new _ellipsis_schema() method:
  • Python mode: only accepts the ... object itself.
  • JSON mode: accepts the string "..." and turns it into .... JSON has no way to represent ..., so a string is the only option.
  • Serialization: Python-mode dumps return ...; JSON-mode dumps return "...". For any value that isn't ..., it raises PydanticSerializationUnexpectedValue, the same way the IP-address serializer just below it does.
  • JSON schema: {'const': '...', 'type': 'string'}.
  • docs/api/standard_library_types.md: a short "Ellipsis" section after "None types".
  • tests/test_types.py: five test functions (12 cases).

The final review caught a bug in the first version: the JSON serializer returned "..." for every value. With EllipsisType | int, dumping (1, ...) gave ["...", "..."]. I added a test for that ordering, saw it fail with exactly that output, and fixed the serializer as described above.

Test evidence:

  • ./bt-test tests/test_types.py -k ellipsis: 12 passed. All of these failed before the fix.
  • ./bt-test tests/test_types.py tests/test_json_schema.py tests/test_main.py: 1741 passed, 31 skipped, 3 xfailed, 0 failures.
  • I didn't change any existing test.

Requirements:

  1. Support the built-in Ellipsis type: done, through types.EllipsisType. The report's exact spelling, int | Ellipsis, is a TypeError in Python itself, before pydantic is involved, so it can't be supported. int | EllipsisType is the valid form.
  2. The report's scenario, tuple[int | EllipsisType, int | EllipsisType]: done. test_ellipsis_type_in_model_union_tuple covers validating (1, ...) and (..., 2), JSON input [1, "..."], Python and JSON dumps, and rejecting the string '...' in Python mode. test_ellipsis_type_union_first_serialization covers EllipsisType | int and the serialization warning for a wrong value.
  3. Validation, serialization and JSON schema: all three are covered by test_ellipsis_type, with the invalid-input tests for Python and JSON.
  4. The ticked checklist items and the "Affected Components" list: no action needed. Both boxes the reporter ticked only confirm they searched first and read the docs, and none of the component boxes are ticked.

The changes are uncommitted in the working tree.