Backtestspydanticrun-20260930-144322#13467
Support Ellipsis
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
The issue
View on GitHubInitial 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
- Compatibility between releases
- Data validation/parsing
- Data serialization -
.model_dump()and.model_dump_json() - JSON Schema
- Dataclasses
- Model Config
- Field Types - adding or changing a particular data type
- Function validation decorator
- Generic Models
- Other Model behaviour -
model_construct(), pickling, private attributes, ORM mode - Plugins and integration with other tools - mypy, FastAPI, python-devtools, Hypothesis, VS Code, PyCharm, etc.
The two patches
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
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 anEllipsisTypeentry next toNoneTypein 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 raisesPydanticSerializationUnexpectedValue, 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:
- Support the built-in Ellipsis type: done, through
types.EllipsisType. The report's exact spelling,int | Ellipsis, is aTypeErrorin Python itself, before pydantic is involved, so it can't be supported.int | EllipsisTypeis the valid form. - The report's scenario,
tuple[int | EllipsisType, int | EllipsisType]: done.test_ellipsis_type_in_model_union_tuplecovers validating(1, ...)and(..., 2), JSON input[1, "..."], Python and JSON dumps, and rejecting the string'...'in Python mode.test_ellipsis_type_union_first_serializationcoversEllipsisType | intand the serialization warning for a wrong value. - Validation, serialization and JSON schema: all three are covered by
test_ellipsis_type, with the invalid-input tests for Python and JSON. - 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.