Backtestspydanticrun-20261002-175417#13599
PEP 695 type aliases don't work with callable discriminators
Error
The harness couldn't finish this ticket.
The solver hit its turn or time cap.. No judgment was produced for this ticket. It counts as an error in the run total.
Solve
1h 42m
Wall-clock time in the container
Full test suite
Not run
The harness did not reach the test stage
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
0vs 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+0 −0
No patch was produced.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()`)", )