Backtestspydanticrun-20260930-183947#13599
PEP 695 type aliases don't work with callable discriminators
Better
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the root cause in the same way. `apply_discriminator()` now forwards `definitions` to `Discriminator._convert_schema()`, so `definition-ref` schemas from PEP 695 aliases can be resolved without a `handler`. That covers both the top-level alias (the issue's M3 case) and alias-built choices. On correctness they are close to equivalent. One small difference: Patch A resolves an alias-built choice only to read its tag metadata and keeps the original `definition-ref` as the union choice. Patch B, like the old handler path, replaces the choice with the resolved definition. A's approach is slightly safer for recursive or shared definitions, though both should work for the reported case. Error handling is also comparable: A raises `MissingDefinitionForUnionRef` (suppressing the LookupError chain), while B returns None and raises in the caller. The clearest difference is in testing. Patch A adds three tests: the top-level alias case (including a generic `TypeAliasType` with type params and an assertion on the `union_tag_invalid` error), an alias used as one choice inside a union with a callable discriminator, and the deferred/`model_rebuild()` path, which exercises `apply_discriminator` with `definitions`. Patch B adds a single happy-path test for one alias value, and its docstring is a leftover `"<link>"` placeholder. A's broader tests cover the new definitions-based resolution paths that B leaves unverified. A's docstring on `_convert_schema` also documents the new parameter clearly. Overall, A is the better patch.
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
9m 50s
Wall-clock time in the container
Full test suite
No new failures
12,323 passed · 499 skipped · 12,822 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
115vs 60 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial Checks
- I confirm that I'm using Pydantic V2
Description
New type aliases prefixed with the type keyword are not supported as the type annotation for a callable discriminator.
M1, M2, M4 ok
M3
pydantic.errors.PydanticUserError: `Tag` not provided for choice {'type': 'definition-ref', 'schema_ref': '__main__.TaggedAnyA:2210408548368'} used with `Discriminator`
Example Code from #12843 also doesn’t work.
Example Code
import traceback
from sys import stderr
from pydantic import BaseModel, Discriminator, Field, Tag
from typing_extensions import Annotated, Any, Literal, TypeAlias
class A(BaseModel):
type_: str
class A1(A):
type_: Literal['A1'] = Field(alias='type')
class A2(A):
type_: Literal['A2'] = Field(alias='type')
def _discriminator(data: Any) -> str:
if isinstance(data, dict):
return data['type']
return data.type_
discriminator = Discriminator(_discriminator)
type AnyA = A1 | A2
AnyA_old: TypeAlias = A1 | A2
type TaggedAnyA = Annotated[A1, Tag('A1')] | Annotated[A2, Tag('A2')]
TaggedAnyA_old: TypeAlias = Annotated[A1, Tag('A1')] | Annotated[A2, Tag('A2')]
_data = {"a" : {'type': 'A1'}}
try:
class M1(BaseModel):
a: AnyA = Field(discriminator='type_')
M1.model_validate(_data)
except Exception as e:
traceback.print_exc()
else:
print("OK", file=stderr)
try:
class M2(BaseModel):
a: AnyA_old = Field(discriminator='type_')
M2.model_validate(_data)
except Exception as e:
traceback.print_exc()
else:
print("OK", file=stderr)
try:
class M3(BaseModel):
a: TaggedAnyA = Field(discriminator=discriminator)
M3.model_validate(_data)
except Exception as e:
traceback.print_exc()
else:
print("OK", file=stderr)
try:
class M4(BaseModel):
a: TaggedAnyA_old = Field(discriminator=discriminator)
M4.model_validate(_data)
except Exception as e:
traceback.print_exc()
else:
print("OK", file=stderr)
Python, Pydantic & OS Version
pydantic version: 2.13.4
pydantic-core version: 2.46.4
pydantic-core build: profile=release pgo=false
python version: 3.14.7 (tags/v3.14.7:823f032, Aug 5 2026, 10:51:32) [MSC v.1944 64 bit (AMD64)]
platform: Windows-11-10.0.26200-SP0
related packages: mypy-2.3.0 typing_extensions-4.16.0
commit: unknownThe two patches
Our patch+101 −14
pydantic/_internal/_discriminated_union.pyindex 94c82026..64f23145 100644@@ -65,7 +65,7 @@ def apply_discriminator( if isinstance(discriminator.discriminator, str): discriminator = discriminator.discriminator else:- return discriminator._convert_schema(schema)+ return discriminator._convert_schema(schema, definitions=definitions) return _ApplyInferredDiscriminator(discriminator, definitions or {}).apply(schema) pydantic/types.pyindex f32a2ab8..601b2923 100644@@ -3112,16 +3112,32 @@ class Discriminator: return self._convert_schema(original_schema, handler) def _convert_schema(- self, original_schema: core_schema.CoreSchema, handler: GetCoreSchemaHandler | None = None+ self,+ original_schema: core_schema.CoreSchema,+ handler: GetCoreSchemaHandler | None = None,+ definitions: dict[str, core_schema.CoreSchema] | None = None, ) -> core_schema.TaggedUnionSchema:- if handler is not None and original_schema['type'] == 'definition-ref':- # Same logic as `_ApplyInferredDiscriminator._apply_to_root()`- try:- def_schema = handler.resolve_ref_schema(original_schema)- except LookupError: # pragma: no cover- from pydantic._internal._discriminated_union import MissingDefinitionForUnionRef+ """Convert `original_schema` to a tagged union schema using the callable discriminator. - raise MissingDefinitionForUnionRef(original_schema['schema_ref'])+ `'definition-ref'` schemas (e.g. produced by PEP 695 type aliases) are resolved using `handler`+ when provided, or else using the `definitions` mapping (used by+ [`apply_discriminator()`][pydantic._internal._discriminated_union.apply_discriminator]).+ """+ from pydantic._internal._discriminated_union import MissingDefinitionForUnionRef++ def resolve_ref(schema: core_schema.DefinitionReferenceSchema) -> core_schema.CoreSchema:+ if handler is not None:+ try:+ return handler.resolve_ref_schema(schema)+ except LookupError:+ raise MissingDefinitionForUnionRef(schema['schema_ref']) from None+ if definitions is not None and schema['schema_ref'] in definitions:+ return definitions[schema['schema_ref']]+ raise MissingDefinitionForUnionRef(schema['schema_ref'])++ if original_schema['type'] == 'definition-ref':+ # Same logic as `_ApplyInferredDiscriminator._apply_to_root()`+ def_schema = resolve_ref(original_schema) # If using a referenceable union as discriminated (e.g. `type Pet = Cat | Dog; field: Pet = Field(discriminator=...)`): if def_schema['type'] == 'union':@@ -3144,15 +3160,14 @@ class Discriminator: if metadata is not None: tag = metadata.get('pydantic_internal_union_tag_key') or tag if tag is None:- # `handler` is None when this method is called from `apply_discriminator()` (deferred discriminators)- if handler is not None and choice['type'] == 'definition-ref':+ if choice['type'] == 'definition-ref': # If choice was built from a PEP 695 type alias, try to resolve the def: try:- choice = handler.resolve_ref_schema(choice)- except LookupError:+ def_choice = resolve_ref(choice)+ except MissingDefinitionForUnionRef: pass else:- metadata = cast('CoreMetadata | None', choice.get('metadata'))+ metadata = cast('CoreMetadata | None', def_choice.get('metadata')) if metadata is not None: tag = metadata.get('pydantic_internal_union_tag_key') tests/types/unions/test_discriminated_union.pyindex fccb82fb..a863eef2 100644@@ -2338,6 +2338,78 @@ def test_discriminated_union_type_alias_type_separate_callable_discriminator() - assert m.g == Bar(type='bar') +def test_discriminated_union_type_alias_type_callable_discriminator_field() -> None:+ """PEP 695 type alias used with `Field(discriminator=Discriminator(<callable>))`."""++ class Foo(BaseModel):+ type: Literal['foo']++ class Bar(BaseModel):+ type: Literal['bar']++ FooBar = TypeAliasType('FooBar', Annotated[Foo, Tag('foo')] | Annotated[Bar, Tag('bar')])++ T = TypeVar('T')++ FooBarTV = TypeAliasType('FooBarTV', Annotated[Foo, Tag('foo')] | Annotated[Bar, Tag('bar')], type_params=(T,))++ class Main(BaseModel):+ f: FooBar = Field(discriminator=Discriminator(lambda v: v['type']))+ g: FooBarTV[int] = Field(discriminator=Discriminator(lambda v: v['type']))++ m = Main(f={'type': 'foo'}, g={'type': 'bar'})++ assert m.f == Foo(type='foo')+ assert m.g == Bar(type='bar')++ with pytest.raises(ValidationError) as exc_info:+ Main(f={'type': 'baz'}, g={'type': 'bar'})++ assert exc_info.value.errors(include_url=False) == [+ {+ 'type': 'union_tag_invalid',+ 'loc': ('f',),+ 'msg': "Input tag 'baz' found using <lambda>() does not match any of the expected tags: 'foo', 'bar'",+ 'input': {'type': 'baz'},+ 'ctx': {'discriminator': '<lambda>()', 'tag': 'baz', 'expected_tags': "'foo', 'bar'"},+ }+ ]+++def test_discriminated_union_type_alias_type_choice_callable_discriminator_field() -> None:+ class Foo(BaseModel):+ type: Literal['foo']++ class Bar(BaseModel):+ type: Literal['bar']++ TaggedFoo = TypeAliasType('TaggedFoo', Annotated[Foo, Tag('foo')])++ class Main(BaseModel):+ f: TaggedFoo | Annotated[Bar, Tag('bar')] = Field(discriminator=Discriminator(lambda v: v['type']))++ assert Main(f={'type': 'foo'}).f == Foo(type='foo')+ assert Main(f={'type': 'bar'}).f == Bar(type='bar')+++def test_discriminated_union_type_alias_type_callable_discriminator_field_deferred() -> None:+ FooBar = TypeAliasType('FooBar', "Annotated[Foo, Tag('foo')] | Annotated[Bar, Tag('bar')]")++ class Main(BaseModel):+ f: FooBar = Field(discriminator=Discriminator(lambda v: v['type']))++ class Foo(BaseModel):+ type: Literal['foo']++ class Bar(BaseModel):+ type: Literal['bar']++ Main.model_rebuild()++ assert Main(f={'type': 'foo'}).f == Foo(type='foo')+ assert Main(f={'type': 'bar'}).f == Bar(type='bar')++ @pytest.mark.xfail( reason="Nested references aren't flattened (see comment in `_ApplyInferredDiscriminator._handle_choice()`)", )
Merged fix · PR #13604+47 −13
pydantic/_internal/_discriminated_union.pyindex 94c82026c..64f231459 100644@@ -65,7 +65,7 @@ def apply_discriminator( if isinstance(discriminator.discriminator, str): discriminator = discriminator.discriminator else:- return discriminator._convert_schema(schema)+ return discriminator._convert_schema(schema, definitions=definitions) return _ApplyInferredDiscriminator(discriminator, definitions or {}).apply(schema) pydantic/types.pyindex f32a2ab80..50f94cf43 100644@@ -3112,13 +3112,29 @@ class Discriminator: return self._convert_schema(original_schema, handler) def _convert_schema(- self, original_schema: core_schema.CoreSchema, handler: GetCoreSchemaHandler | None = None+ self,+ original_schema: core_schema.CoreSchema,+ handler: GetCoreSchemaHandler | None = None,+ definitions: dict[str, core_schema.CoreSchema] | None = None, ) -> core_schema.TaggedUnionSchema:- if handler is not None and original_schema['type'] == 'definition-ref':+ def _resolve_ref(schema: core_schema.CoreSchema) -> core_schema.CoreSchema | None:+ # `handler` is set when this method is called while generating the schema for the field+ # (e.g. via `Annotated[<type>, Discriminator(...)]`). `definitions` is set instead when+ # this method is called from `apply_discriminator()` (deferred/callable discriminators).+ if handler is not None:+ try:+ return handler.resolve_ref_schema(schema)+ except LookupError: # pragma: no cover+ return None+ elif definitions is not None:+ schema_ref = cast(core_schema.DefinitionReferenceSchema, schema)['schema_ref']+ return definitions.get(schema_ref)+ return None++ if original_schema['type'] == 'definition-ref': # Same logic as `_ApplyInferredDiscriminator._apply_to_root()`- try:- def_schema = handler.resolve_ref_schema(original_schema)- except LookupError: # pragma: no cover+ def_schema = _resolve_ref(original_schema)+ if def_schema is None: from pydantic._internal._discriminated_union import MissingDefinitionForUnionRef raise MissingDefinitionForUnionRef(original_schema['schema_ref'])@@ -3144,14 +3160,11 @@ class Discriminator: if metadata is not None: tag = metadata.get('pydantic_internal_union_tag_key') or tag if tag is None:- # `handler` is None when this method is called from `apply_discriminator()` (deferred discriminators)- if handler is not None and choice['type'] == 'definition-ref':+ if choice['type'] == 'definition-ref': # If choice was built from a PEP 695 type alias, try to resolve the def:- try:- choice = handler.resolve_ref_schema(choice)- except LookupError:- pass- else:+ resolved_choice = _resolve_ref(choice)+ if resolved_choice is not None:+ choice = resolved_choice metadata = cast('CoreMetadata | None', choice.get('metadata')) if metadata is not None: tag = metadata.get('pydantic_internal_union_tag_key')tests/types/unions/test_discriminated_union.pyindex fccb82fbb..637679102 100644@@ -2338,6 +2338,27 @@ def test_discriminated_union_type_alias_type_separate_callable_discriminator() - assert m.g == Bar(type='bar') +def test_discriminated_union_type_alias_type_separate_callable_discriminator_field() -> None:+ """https://github.com/pydantic/pydantic/issues/13599"""++ class Foo(BaseModel):+ type: Literal['foo']++ class Bar(BaseModel):+ type: Literal['bar']++ FooBar = TypeAliasType('FooBar', Annotated[Foo, Tag('foo')] | Annotated[Bar, Tag('bar')])++ discriminator = Discriminator(lambda v: v['type'])++ class Main(BaseModel):+ f: FooBar = Field(discriminator=discriminator)++ m = Main(f={'type': 'foo'})++ assert m.f == Foo(type='foo')++ @pytest.mark.xfail( reason="Nested references aren't flattened (see comment in `_ApplyInferredDiscriminator._handle_choice()`)", )