Bug Report: Possible regression in typer 0.12.4 with list of union argument parsing

[aldbr]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the Typer documentation, with the integrated search.
• I already searched in Google "How to X in Typer" and didn't find any information.
• I already read and followed all the tutorials in the docs and didn't find an answer.
• I already checked if it is not related to Typer but to Click.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import typer
from typer import Option
from typing import Annotated

app = typer.Typer()

def parse_union(item: str) -> int | str:
    if item.isdigit():
        return int(item)
    return item

@app.command()
def main(items: Annotated[list[int | str], Option(parser=parse_union)] = []):
    print(items)

if __name__ == "__main__":
    app()

Description

After upgrading to typer 0.12.4, the handling of command-line arguments with types like List[Union[int, str]] - combined with a parser - appears to be broken. This behavior worked correctly in typer 0.12.3 but now raises an assertion error.

Previous (Expected?) Behavior (typer 0.12.3):
Executing the following command should work as expected:

$ python example.py --items 4
[4]

Actual Behavior (typer 0.12.4):
Running the same command now results in an error:

$ python example.py --items 4
AssertionError: List types with complex sub-types are not currently supported

Analysis:

This regression seems to have been introduced in commit 218bf89, where additional checks were added to the type parsing logic.

• typer 0.12.3 implementation: The type checks were more lenient and allowed unions within list types:
  

  typer/typer/main.py

  Lines 841 to 846 in 525c777

  	if lenient_issubclass(origin, List):
  	main_type = main_type.__args__[0]
  	assert not getattr(
  	main_type, "__origin__", None
  	), "List types with complex sub-types are not currently supported"
  	is_list = True

• typer 0.12.4 implementation: The updated checks introduced stricter validation, which now causes this use case to fail:
  

  typer/typer/main.py

  Lines 843 to 848 in 29d1d1f

  	if lenient_issubclass(origin, List):
  	main_type = get_args(main_type)[0]
  	assert not get_origin(
  	main_type
  	), "List types with complex sub-types are not currently supported"
  	is_list = True

  
  

  typer/typer/_typing.py

  Line 133 in 29d1d1f

  return _typing_get_origin(tp) or getattr(tp, "__origin__", None)

Reproducer:

Here is a minimal example to demonstrate the difference between the two versions:

from typer._typing import get_args
from typing import List
from typing import get_origin as _typing_get_origin


problematic_type = List[str | int]

# typer 0.12.3
# https://github.com/fastapi/typer/blob/525c7779ba8914b3950b26ffa21decdfd3eec6ec/typer/main.py#L841-L846

main_type = problematic_type.__args__[0]
print(main_type)
result = getattr(str | int, "__origin__", None)
print(result)

assert not result

# typer 0.12.4
# https://github.com/fastapi/typer/blob/29d1d1fafe92d27b37462c90d67ce8687bab0341/typer/main.py#L843-L848

main_type = get_args(problematic_type)[0]
print(main_type)
result = _typing_get_origin(main_type)
print(result)

assert not result # Will trigger an assertion error!

Question:

Is this behavior change expected in typer 0.12.4? If so, could you provide guidance on how to properly handle List[Union[int, str]] arguments combined with parser moving forward? If this change was unintentional, could it be addressed in a future release?

Thanks

Operating System

Linux

Operating System Details

No response

Typer Version

0.12.4

Python Version

3.11.9

Additional Context

No response

[svlandeg]

Thanks for the report! We'll look into this 🙏

[svlandeg]

I'm still looking into this, but to come back to

The type checks were more lenient and allowed unions within list types

That was indeed the case, because getattr(str | int, "__origin__", None) returns None, just like getattr(str | None, "__origin__", None) returns None. This in effect means that str | int or str | None are then seen as "simple" types, not generic ones. But taking a step back, I don't think that's actually correct? The definition matters, because the Typer code you cited triggers the assert for "non-simple" types.

To make things worse, the getattr check by itself doesn't seem consistent. Because both getattr(Optional[str], "__origin__", None) and getattr(Union[str, None], "__origin__", None) DO return typing.Union and thus would be seen as generic types (which feels correct, but inconsistent with the previous paragraph).

Using the get_origin() method however, the variants with | refer to types.UnionType which will be seen as a _typing.is_union() case, which then feels more consistent overall because you'd get the same result with any of the notations.

Let me know if the above makes sense to you or not.

If it does - I'm starting to wonder whether your use-case from the example code snippet sort of "worked by accident" in 0.12.3. And if it did, then can't we make it work on purpose going forward 😁

[aldbr]

Thanks a lot for the detailed explanation 🙂

Using the get_origin() method however, the variants with | refer to types.UnionType which will be seen as a _typing.is_union() case, which then feels more consistent overall because you'd get the same result with any of the notations.

Yes I agree - it does feel more consistent overall, and seems to be the right approach.

If it does - I'm starting to wonder whether your use-case from the example code snippet sort of "worked by accident" in 0.12.3. And if it did, then can't we make it work on purpose going forward 😁

Yes I also think that it "worked by accident", but it worked nonetheless. This makes me wonder whether it makes sense to completely prevent union of simple types. However, I don't have enough insight to say where the boundary should be set. Any opinion?

If you think it makes sense, then I could just write the following code and the issue would be solved:

import typer
from typer import Option
from typing import Annotated

app = typer.Typer()

def parse_union(item: str) -> int | str:
    if item.isdigit():
        return int(item)
    return item

@app.command()
def main(items: list[str] = []):
    items = [parse_union(item) for item in items]
    print(items)

if __name__ == "__main__":
    app()

[svlandeg]

Yea I think that would be the best approach for now 👍